from mhcgnomes import Allele, parse


def test_A_01_01_01_01():
    result = parse("A*01:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_02N():
    result = parse("A*01:01:01:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:02N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_03():
    result = parse("A*01:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_04():
    result = parse("A*01:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_05():
    result = parse("A*01:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_06():
    result = parse("A*01:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_07():
    result = parse("A*01:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_08():
    result = parse("A*01:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_09():
    result = parse("A*01:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_10():
    result = parse("A*01:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_11():
    result = parse("A*01:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_12():
    result = parse("A*01:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_13():
    result = parse("A*01:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_14():
    result = parse("A*01:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_15():
    result = parse("A*01:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_16():
    result = parse("A*01:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_17():
    result = parse("A*01:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_18():
    result = parse("A*01:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_19():
    result = parse("A*01:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_20():
    result = parse("A*01:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_21():
    result = parse("A*01:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_22():
    result = parse("A*01:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_23():
    result = parse("A*01:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_24():
    result = parse("A*01:01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_25():
    result = parse("A*01:01:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_26():
    result = parse("A*01:01:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_27():
    result = parse("A*01:01:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_28():
    result = parse("A*01:01:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_29():
    result = parse("A*01:01:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_30():
    result = parse("A*01:01:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_31():
    result = parse("A*01:01:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_32():
    result = parse("A*01:01:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_33():
    result = parse("A*01:01:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_34():
    result = parse("A*01:01:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_35():
    result = parse("A*01:01:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_36():
    result = parse("A*01:01:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_37():
    result = parse("A*01:01:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_38():
    result = parse("A*01:01:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_39():
    result = parse("A*01:01:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_40():
    result = parse("A*01:01:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_41():
    result = parse("A*01:01:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_42():
    result = parse("A*01:01:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_43():
    result = parse("A*01:01:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_44():
    result = parse("A*01:01:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_45():
    result = parse("A*01:01:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:45") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_46():
    result = parse("A*01:01:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:46") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_47():
    result = parse("A*01:01:01:47")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:47") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_48():
    result = parse("A*01:01:01:48")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:48") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:48") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_49():
    result = parse("A*01:01:01:49")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:49") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:49") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_50():
    result = parse("A*01:01:01:50")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:50") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:50") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_51():
    result = parse("A*01:01:01:51")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:51") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:51") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_52():
    result = parse("A*01:01:01:52")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:52") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:52") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_53():
    result = parse("A*01:01:01:53")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:53") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:53") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_54():
    result = parse("A*01:01:01:54")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:54") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:54") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_55():
    result = parse("A*01:01:01:55")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:55") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:55") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_56():
    result = parse("A*01:01:01:56")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:56") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:56") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_57():
    result = parse("A*01:01:01:57")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:57") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:57") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_01_58():
    result = parse("A*01:01:01:58")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:01:58") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:01:01:58") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_02():
    result = parse("A*01:01:02")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_03():
    result = parse("A*01:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_04():
    result = parse("A*01:01:04")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_05():
    result = parse("A*01:01:05")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_06():
    result = parse("A*01:01:06")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_07():
    result = parse("A*01:01:07")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_08():
    result = parse("A*01:01:08")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_09():
    result = parse("A*01:01:09")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_10():
    result = parse("A*01:01:10")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_100():
    result = parse("A*01:01:100")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:100") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_101():
    result = parse("A*01:01:101")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:101") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_102():
    result = parse("A*01:01:102")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:102") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_103():
    result = parse("A*01:01:103")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:103") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_104():
    result = parse("A*01:01:104")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:104") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_105():
    result = parse("A*01:01:105")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:105") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_106():
    result = parse("A*01:01:106")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:106") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_107():
    result = parse("A*01:01:107")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:107") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_108():
    result = parse("A*01:01:108")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:108") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_109():
    result = parse("A*01:01:109")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:109") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_11():
    result = parse("A*01:01:11")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_110():
    result = parse("A*01:01:110")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:110") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_111():
    result = parse("A*01:01:111")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:111") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_112():
    result = parse("A*01:01:112")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:112") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_113():
    result = parse("A*01:01:113")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:113") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_114():
    result = parse("A*01:01:114")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:114") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_115():
    result = parse("A*01:01:115")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:115") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:115") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_116():
    result = parse("A*01:01:116")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:116") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_117():
    result = parse("A*01:01:117")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:117") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_12():
    result = parse("A*01:01:12")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_13():
    result = parse("A*01:01:13")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_14():
    result = parse("A*01:01:14")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_15():
    result = parse("A*01:01:15")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_16():
    result = parse("A*01:01:16")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_17():
    result = parse("A*01:01:17")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_18():
    result = parse("A*01:01:18")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_19():
    result = parse("A*01:01:19")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_20():
    result = parse("A*01:01:20")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_21():
    result = parse("A*01:01:21")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_22():
    result = parse("A*01:01:22")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_23():
    result = parse("A*01:01:23")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_24():
    result = parse("A*01:01:24")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_25():
    result = parse("A*01:01:25")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_26():
    result = parse("A*01:01:26")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_27():
    result = parse("A*01:01:27")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_28():
    result = parse("A*01:01:28")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_29():
    result = parse("A*01:01:29")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_30():
    result = parse("A*01:01:30")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_31():
    result = parse("A*01:01:31")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_32():
    result = parse("A*01:01:32")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_33():
    result = parse("A*01:01:33")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_34():
    result = parse("A*01:01:34")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_35():
    result = parse("A*01:01:35")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_36():
    result = parse("A*01:01:36")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_37():
    result = parse("A*01:01:37")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_38L():
    result = parse("A*01:01:38L")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:01:38L") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:38L") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_39():
    result = parse("A*01:01:39")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_40():
    result = parse("A*01:01:40")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_41():
    result = parse("A*01:01:41")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_42():
    result = parse("A*01:01:42")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_43():
    result = parse("A*01:01:43")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_44():
    result = parse("A*01:01:44")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_45():
    result = parse("A*01:01:45")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_46():
    result = parse("A*01:01:46")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_47():
    result = parse("A*01:01:47")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_48():
    result = parse("A*01:01:48")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_49():
    result = parse("A*01:01:49")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_50():
    result = parse("A*01:01:50")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_51():
    result = parse("A*01:01:51")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_52():
    result = parse("A*01:01:52")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_53():
    result = parse("A*01:01:53")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_54():
    result = parse("A*01:01:54")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_55():
    result = parse("A*01:01:55")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_56():
    result = parse("A*01:01:56")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_57():
    result = parse("A*01:01:57")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_58():
    result = parse("A*01:01:58")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_59():
    result = parse("A*01:01:59")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_60():
    result = parse("A*01:01:60")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_61():
    result = parse("A*01:01:61")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_62():
    result = parse("A*01:01:62")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_63():
    result = parse("A*01:01:63")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_64():
    result = parse("A*01:01:64")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_65():
    result = parse("A*01:01:65")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_66():
    result = parse("A*01:01:66")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:66") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:66") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_67():
    result = parse("A*01:01:67")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:67") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:67") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_68():
    result = parse("A*01:01:68")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:68") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:68") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_69():
    result = parse("A*01:01:69")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:69") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:69") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_70():
    result = parse("A*01:01:70")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:70") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:70") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_71():
    result = parse("A*01:01:71")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:71") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:71") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_72():
    result = parse("A*01:01:72")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:72") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:72") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_73():
    result = parse("A*01:01:73")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:73") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:73") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_74():
    result = parse("A*01:01:74")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:74") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:74") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_75():
    result = parse("A*01:01:75")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:75") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:75") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_76():
    result = parse("A*01:01:76")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:76") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:76") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_77():
    result = parse("A*01:01:77")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:77") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:77") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_78():
    result = parse("A*01:01:78")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:78") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:78") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_79():
    result = parse("A*01:01:79")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:79") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:79") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_80():
    result = parse("A*01:01:80")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:80") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:80") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_81():
    result = parse("A*01:01:81")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:81") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:81") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_82():
    result = parse("A*01:01:82")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:82") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:82") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_83():
    result = parse("A*01:01:83")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:83") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:83") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_84():
    result = parse("A*01:01:84")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:84") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:84") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_85():
    result = parse("A*01:01:85")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:85") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:85") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_86():
    result = parse("A*01:01:86")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:86") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:86") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_87():
    result = parse("A*01:01:87")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:87") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:87") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_88():
    result = parse("A*01:01:88")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:88") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:88") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_89():
    result = parse("A*01:01:89")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:89") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:89") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_90():
    result = parse("A*01:01:90")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:90") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:90") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_91():
    result = parse("A*01:01:91")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:91") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:91") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_92():
    result = parse("A*01:01:92")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:92") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:92") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_93():
    result = parse("A*01:01:93")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:93") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:93") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_94():
    result = parse("A*01:01:94")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:94") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:94") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_95():
    result = parse("A*01:01:95")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:95") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:95") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_96():
    result = parse("A*01:01:96")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:96") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:96") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_97():
    result = parse("A*01:01:97")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:97") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:97") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_98():
    result = parse("A*01:01:98")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:98") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:98") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_01_99():
    result = parse("A*01:01:99")
    assert result.__class__ is Allele, f'Expected parse("A*01:01:99") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:01:99") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_02_01():
    result = parse("A*01:02:01")
    assert result.__class__ is Allele, f'Expected parse("A*01:02:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_02_02():
    result = parse("A*01:02:02")
    assert result.__class__ is Allele, f'Expected parse("A*01:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_03_01_01():
    result = parse("A*01:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_03_01_02():
    result = parse("A*01:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_03_02():
    result = parse("A*01:03:02")
    assert result.__class__ is Allele, f'Expected parse("A*01:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_04_01_01N():
    result = parse("A*01:04:01:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:04:01:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:04:01:01N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_04_01_02N():
    result = parse("A*01:04:01:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:04:01:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:04:01:02N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_06():
    result = parse("A*01:06")
    assert result.__class__ is Allele, f'Expected parse("A*01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_07():
    result = parse("A*01:07")
    assert result.__class__ is Allele, f'Expected parse("A*01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_08():
    result = parse("A*01:08")
    assert result.__class__ is Allele, f'Expected parse("A*01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_09_01_01():
    result = parse("A*01:09:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:09:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:09:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_09_01_02():
    result = parse("A*01:09:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:09:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:09:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_09_02():
    result = parse("A*01:09:02")
    assert result.__class__ is Allele, f'Expected parse("A*01:09:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:09:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_10():
    result = parse("A*01:10")
    assert result.__class__ is Allele, f'Expected parse("A*01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_100():
    result = parse("A*01:100")
    assert result.__class__ is Allele, f'Expected parse("A*01:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_101():
    result = parse("A*01:101")
    assert result.__class__ is Allele, f'Expected parse("A*01:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_102():
    result = parse("A*01:102")
    assert result.__class__ is Allele, f'Expected parse("A*01:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_103():
    result = parse("A*01:103")
    assert result.__class__ is Allele, f'Expected parse("A*01:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_104():
    result = parse("A*01:104")
    assert result.__class__ is Allele, f'Expected parse("A*01:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_105():
    result = parse("A*01:105")
    assert result.__class__ is Allele, f'Expected parse("A*01:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_106():
    result = parse("A*01:106")
    assert result.__class__ is Allele, f'Expected parse("A*01:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_107():
    result = parse("A*01:107")
    assert result.__class__ is Allele, f'Expected parse("A*01:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_108():
    result = parse("A*01:108")
    assert result.__class__ is Allele, f'Expected parse("A*01:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_109():
    result = parse("A*01:109")
    assert result.__class__ is Allele, f'Expected parse("A*01:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_110():
    result = parse("A*01:110")
    assert result.__class__ is Allele, f'Expected parse("A*01:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_111():
    result = parse("A*01:111")
    assert result.__class__ is Allele, f'Expected parse("A*01:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_112():
    result = parse("A*01:112")
    assert result.__class__ is Allele, f'Expected parse("A*01:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_113():
    result = parse("A*01:113")
    assert result.__class__ is Allele, f'Expected parse("A*01:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_114():
    result = parse("A*01:114")
    assert result.__class__ is Allele, f'Expected parse("A*01:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_115():
    result = parse("A*01:115")
    assert result.__class__ is Allele, f'Expected parse("A*01:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_116():
    result = parse("A*01:116")
    assert result.__class__ is Allele, f'Expected parse("A*01:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_117():
    result = parse("A*01:117")
    assert result.__class__ is Allele, f'Expected parse("A*01:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_118():
    result = parse("A*01:118")
    assert result.__class__ is Allele, f'Expected parse("A*01:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_119():
    result = parse("A*01:119")
    assert result.__class__ is Allele, f'Expected parse("A*01:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_11N():
    result = parse("A*01:11N")
    assert result.__class__ is Allele, f'Expected parse("A*01:11N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:11N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_12():
    result = parse("A*01:12")
    assert result.__class__ is Allele, f'Expected parse("A*01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_120():
    result = parse("A*01:120")
    assert result.__class__ is Allele, f'Expected parse("A*01:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_121():
    result = parse("A*01:121")
    assert result.__class__ is Allele, f'Expected parse("A*01:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_122():
    result = parse("A*01:122")
    assert result.__class__ is Allele, f'Expected parse("A*01:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_123N():
    result = parse("A*01:123N")
    assert result.__class__ is Allele, f'Expected parse("A*01:123N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:123N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_124():
    result = parse("A*01:124")
    assert result.__class__ is Allele, f'Expected parse("A*01:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_125():
    result = parse("A*01:125")
    assert result.__class__ is Allele, f'Expected parse("A*01:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_126():
    result = parse("A*01:126")
    assert result.__class__ is Allele, f'Expected parse("A*01:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_127():
    result = parse("A*01:127")
    assert result.__class__ is Allele, f'Expected parse("A*01:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_128():
    result = parse("A*01:128")
    assert result.__class__ is Allele, f'Expected parse("A*01:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_129():
    result = parse("A*01:129")
    assert result.__class__ is Allele, f'Expected parse("A*01:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_13():
    result = parse("A*01:13")
    assert result.__class__ is Allele, f'Expected parse("A*01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_130():
    result = parse("A*01:130")
    assert result.__class__ is Allele, f'Expected parse("A*01:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_131():
    result = parse("A*01:131")
    assert result.__class__ is Allele, f'Expected parse("A*01:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_132():
    result = parse("A*01:132")
    assert result.__class__ is Allele, f'Expected parse("A*01:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_133():
    result = parse("A*01:133")
    assert result.__class__ is Allele, f'Expected parse("A*01:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_134():
    result = parse("A*01:134")
    assert result.__class__ is Allele, f'Expected parse("A*01:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_135():
    result = parse("A*01:135")
    assert result.__class__ is Allele, f'Expected parse("A*01:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_136():
    result = parse("A*01:136")
    assert result.__class__ is Allele, f'Expected parse("A*01:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_137():
    result = parse("A*01:137")
    assert result.__class__ is Allele, f'Expected parse("A*01:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_138():
    result = parse("A*01:138")
    assert result.__class__ is Allele, f'Expected parse("A*01:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_139():
    result = parse("A*01:139")
    assert result.__class__ is Allele, f'Expected parse("A*01:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_14():
    result = parse("A*01:14")
    assert result.__class__ is Allele, f'Expected parse("A*01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_140_01():
    result = parse("A*01:140:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:140:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:140:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_140_02():
    result = parse("A*01:140:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:140:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:140:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_141():
    result = parse("A*01:141")
    assert result.__class__ is Allele, f'Expected parse("A*01:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_142():
    result = parse("A*01:142")
    assert result.__class__ is Allele, f'Expected parse("A*01:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_143():
    result = parse("A*01:143")
    assert result.__class__ is Allele, f'Expected parse("A*01:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_144():
    result = parse("A*01:144")
    assert result.__class__ is Allele, f'Expected parse("A*01:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_145():
    result = parse("A*01:145")
    assert result.__class__ is Allele, f'Expected parse("A*01:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_146():
    result = parse("A*01:146")
    assert result.__class__ is Allele, f'Expected parse("A*01:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_147Q():
    result = parse("A*01:147Q")
    assert result.__class__ is Allele, f'Expected parse("A*01:147Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:147Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_148():
    result = parse("A*01:148")
    assert result.__class__ is Allele, f'Expected parse("A*01:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_149():
    result = parse("A*01:149")
    assert result.__class__ is Allele, f'Expected parse("A*01:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_150():
    result = parse("A*01:150")
    assert result.__class__ is Allele, f'Expected parse("A*01:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_151():
    result = parse("A*01:151")
    assert result.__class__ is Allele, f'Expected parse("A*01:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_152():
    result = parse("A*01:152")
    assert result.__class__ is Allele, f'Expected parse("A*01:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_153():
    result = parse("A*01:153")
    assert result.__class__ is Allele, f'Expected parse("A*01:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_154():
    result = parse("A*01:154")
    assert result.__class__ is Allele, f'Expected parse("A*01:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_155():
    result = parse("A*01:155")
    assert result.__class__ is Allele, f'Expected parse("A*01:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_156():
    result = parse("A*01:156")
    assert result.__class__ is Allele, f'Expected parse("A*01:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_157():
    result = parse("A*01:157")
    assert result.__class__ is Allele, f'Expected parse("A*01:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_158():
    result = parse("A*01:158")
    assert result.__class__ is Allele, f'Expected parse("A*01:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_159Q():
    result = parse("A*01:159Q")
    assert result.__class__ is Allele, f'Expected parse("A*01:159Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:159Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_15N():
    result = parse("A*01:15N")
    assert result.__class__ is Allele, f'Expected parse("A*01:15N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:15N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_160N():
    result = parse("A*01:160N")
    assert result.__class__ is Allele, f'Expected parse("A*01:160N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:160N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_161():
    result = parse("A*01:161")
    assert result.__class__ is Allele, f'Expected parse("A*01:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_162N():
    result = parse("A*01:162N")
    assert result.__class__ is Allele, f'Expected parse("A*01:162N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:162N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_163():
    result = parse("A*01:163")
    assert result.__class__ is Allele, f'Expected parse("A*01:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_164():
    result = parse("A*01:164")
    assert result.__class__ is Allele, f'Expected parse("A*01:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_165():
    result = parse("A*01:165")
    assert result.__class__ is Allele, f'Expected parse("A*01:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_166():
    result = parse("A*01:166")
    assert result.__class__ is Allele, f'Expected parse("A*01:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_167():
    result = parse("A*01:167")
    assert result.__class__ is Allele, f'Expected parse("A*01:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_168():
    result = parse("A*01:168")
    assert result.__class__ is Allele, f'Expected parse("A*01:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_169():
    result = parse("A*01:169")
    assert result.__class__ is Allele, f'Expected parse("A*01:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_16N():
    result = parse("A*01:16N")
    assert result.__class__ is Allele, f'Expected parse("A*01:16N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:16N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_17():
    result = parse("A*01:17")
    assert result.__class__ is Allele, f'Expected parse("A*01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_170():
    result = parse("A*01:170")
    assert result.__class__ is Allele, f'Expected parse("A*01:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_171():
    result = parse("A*01:171")
    assert result.__class__ is Allele, f'Expected parse("A*01:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_172():
    result = parse("A*01:172")
    assert result.__class__ is Allele, f'Expected parse("A*01:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_173():
    result = parse("A*01:173")
    assert result.__class__ is Allele, f'Expected parse("A*01:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_174():
    result = parse("A*01:174")
    assert result.__class__ is Allele, f'Expected parse("A*01:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_175():
    result = parse("A*01:175")
    assert result.__class__ is Allele, f'Expected parse("A*01:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_176():
    result = parse("A*01:176")
    assert result.__class__ is Allele, f'Expected parse("A*01:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_177():
    result = parse("A*01:177")
    assert result.__class__ is Allele, f'Expected parse("A*01:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_178N():
    result = parse("A*01:178N")
    assert result.__class__ is Allele, f'Expected parse("A*01:178N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:178N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_179N():
    result = parse("A*01:179N")
    assert result.__class__ is Allele, f'Expected parse("A*01:179N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:179N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_180():
    result = parse("A*01:180")
    assert result.__class__ is Allele, f'Expected parse("A*01:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_181():
    result = parse("A*01:181")
    assert result.__class__ is Allele, f'Expected parse("A*01:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_182():
    result = parse("A*01:182")
    assert result.__class__ is Allele, f'Expected parse("A*01:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_183():
    result = parse("A*01:183")
    assert result.__class__ is Allele, f'Expected parse("A*01:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_184():
    result = parse("A*01:184")
    assert result.__class__ is Allele, f'Expected parse("A*01:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_185():
    result = parse("A*01:185")
    assert result.__class__ is Allele, f'Expected parse("A*01:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_186N():
    result = parse("A*01:186N")
    assert result.__class__ is Allele, f'Expected parse("A*01:186N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:186N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_187():
    result = parse("A*01:187")
    assert result.__class__ is Allele, f'Expected parse("A*01:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_188():
    result = parse("A*01:188")
    assert result.__class__ is Allele, f'Expected parse("A*01:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_189():
    result = parse("A*01:189")
    assert result.__class__ is Allele, f'Expected parse("A*01:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_18N():
    result = parse("A*01:18N")
    assert result.__class__ is Allele, f'Expected parse("A*01:18N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:18N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_19():
    result = parse("A*01:19")
    assert result.__class__ is Allele, f'Expected parse("A*01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_190():
    result = parse("A*01:190")
    assert result.__class__ is Allele, f'Expected parse("A*01:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_191():
    result = parse("A*01:191")
    assert result.__class__ is Allele, f'Expected parse("A*01:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_192():
    result = parse("A*01:192")
    assert result.__class__ is Allele, f'Expected parse("A*01:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_193():
    result = parse("A*01:193")
    assert result.__class__ is Allele, f'Expected parse("A*01:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_194():
    result = parse("A*01:194")
    assert result.__class__ is Allele, f'Expected parse("A*01:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_195():
    result = parse("A*01:195")
    assert result.__class__ is Allele, f'Expected parse("A*01:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_196():
    result = parse("A*01:196")
    assert result.__class__ is Allele, f'Expected parse("A*01:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_197():
    result = parse("A*01:197")
    assert result.__class__ is Allele, f'Expected parse("A*01:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_198():
    result = parse("A*01:198")
    assert result.__class__ is Allele, f'Expected parse("A*01:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_199():
    result = parse("A*01:199")
    assert result.__class__ is Allele, f'Expected parse("A*01:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_20():
    result = parse("A*01:20")
    assert result.__class__ is Allele, f'Expected parse("A*01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_200():
    result = parse("A*01:200")
    assert result.__class__ is Allele, f'Expected parse("A*01:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_201():
    result = parse("A*01:201")
    assert result.__class__ is Allele, f'Expected parse("A*01:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_202():
    result = parse("A*01:202")
    assert result.__class__ is Allele, f'Expected parse("A*01:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_203():
    result = parse("A*01:203")
    assert result.__class__ is Allele, f'Expected parse("A*01:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_204():
    result = parse("A*01:204")
    assert result.__class__ is Allele, f'Expected parse("A*01:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_205():
    result = parse("A*01:205")
    assert result.__class__ is Allele, f'Expected parse("A*01:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_206():
    result = parse("A*01:206")
    assert result.__class__ is Allele, f'Expected parse("A*01:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_207():
    result = parse("A*01:207")
    assert result.__class__ is Allele, f'Expected parse("A*01:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_208Q():
    result = parse("A*01:208Q")
    assert result.__class__ is Allele, f'Expected parse("A*01:208Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:208Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_209():
    result = parse("A*01:209")
    assert result.__class__ is Allele, f'Expected parse("A*01:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_21():
    result = parse("A*01:21")
    assert result.__class__ is Allele, f'Expected parse("A*01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_210_01():
    result = parse("A*01:210:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:210:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:210:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_210_02():
    result = parse("A*01:210:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:210:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:210:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_211():
    result = parse("A*01:211")
    assert result.__class__ is Allele, f'Expected parse("A*01:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_212():
    result = parse("A*01:212")
    assert result.__class__ is Allele, f'Expected parse("A*01:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_213():
    result = parse("A*01:213")
    assert result.__class__ is Allele, f'Expected parse("A*01:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_214():
    result = parse("A*01:214")
    assert result.__class__ is Allele, f'Expected parse("A*01:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_215():
    result = parse("A*01:215")
    assert result.__class__ is Allele, f'Expected parse("A*01:215") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_216():
    result = parse("A*01:216")
    assert result.__class__ is Allele, f'Expected parse("A*01:216") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_217():
    result = parse("A*01:217")
    assert result.__class__ is Allele, f'Expected parse("A*01:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_218():
    result = parse("A*01:218")
    assert result.__class__ is Allele, f'Expected parse("A*01:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_219():
    result = parse("A*01:219")
    assert result.__class__ is Allele, f'Expected parse("A*01:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_220():
    result = parse("A*01:220")
    assert result.__class__ is Allele, f'Expected parse("A*01:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_221():
    result = parse("A*01:221")
    assert result.__class__ is Allele, f'Expected parse("A*01:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_222():
    result = parse("A*01:222")
    assert result.__class__ is Allele, f'Expected parse("A*01:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_223():
    result = parse("A*01:223")
    assert result.__class__ is Allele, f'Expected parse("A*01:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_224():
    result = parse("A*01:224")
    assert result.__class__ is Allele, f'Expected parse("A*01:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_225():
    result = parse("A*01:225")
    assert result.__class__ is Allele, f'Expected parse("A*01:225") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_226():
    result = parse("A*01:226")
    assert result.__class__ is Allele, f'Expected parse("A*01:226") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_227():
    result = parse("A*01:227")
    assert result.__class__ is Allele, f'Expected parse("A*01:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_228Q():
    result = parse("A*01:228Q")
    assert result.__class__ is Allele, f'Expected parse("A*01:228Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:228Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_229():
    result = parse("A*01:229")
    assert result.__class__ is Allele, f'Expected parse("A*01:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_22N():
    result = parse("A*01:22N")
    assert result.__class__ is Allele, f'Expected parse("A*01:22N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:22N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_230():
    result = parse("A*01:230")
    assert result.__class__ is Allele, f'Expected parse("A*01:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_231():
    result = parse("A*01:231")
    assert result.__class__ is Allele, f'Expected parse("A*01:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_232_01():
    result = parse("A*01:232:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:232:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:232:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_232_02():
    result = parse("A*01:232:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:232:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:232:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_233():
    result = parse("A*01:233")
    assert result.__class__ is Allele, f'Expected parse("A*01:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_234():
    result = parse("A*01:234")
    assert result.__class__ is Allele, f'Expected parse("A*01:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_235():
    result = parse("A*01:235")
    assert result.__class__ is Allele, f'Expected parse("A*01:235") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_236():
    result = parse("A*01:236")
    assert result.__class__ is Allele, f'Expected parse("A*01:236") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_237():
    result = parse("A*01:237")
    assert result.__class__ is Allele, f'Expected parse("A*01:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_238():
    result = parse("A*01:238")
    assert result.__class__ is Allele, f'Expected parse("A*01:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_239():
    result = parse("A*01:239")
    assert result.__class__ is Allele, f'Expected parse("A*01:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_23_01():
    result = parse("A*01:23:01")
    assert result.__class__ is Allele, f'Expected parse("A*01:23:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:23:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_23_02():
    result = parse("A*01:23:02")
    assert result.__class__ is Allele, f'Expected parse("A*01:23:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:23:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_24():
    result = parse("A*01:24")
    assert result.__class__ is Allele, f'Expected parse("A*01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_240N():
    result = parse("A*01:240N")
    assert result.__class__ is Allele, f'Expected parse("A*01:240N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:240N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_241():
    result = parse("A*01:241")
    assert result.__class__ is Allele, f'Expected parse("A*01:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_242():
    result = parse("A*01:242")
    assert result.__class__ is Allele, f'Expected parse("A*01:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_243():
    result = parse("A*01:243")
    assert result.__class__ is Allele, f'Expected parse("A*01:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_244():
    result = parse("A*01:244")
    assert result.__class__ is Allele, f'Expected parse("A*01:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_245():
    result = parse("A*01:245")
    assert result.__class__ is Allele, f'Expected parse("A*01:245") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_246():
    result = parse("A*01:246")
    assert result.__class__ is Allele, f'Expected parse("A*01:246") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_247N():
    result = parse("A*01:247N")
    assert result.__class__ is Allele, f'Expected parse("A*01:247N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:247N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_248Q():
    result = parse("A*01:248Q")
    assert result.__class__ is Allele, f'Expected parse("A*01:248Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:248Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_249():
    result = parse("A*01:249")
    assert result.__class__ is Allele, f'Expected parse("A*01:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_25():
    result = parse("A*01:25")
    assert result.__class__ is Allele, f'Expected parse("A*01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_250N():
    result = parse("A*01:250N")
    assert result.__class__ is Allele, f'Expected parse("A*01:250N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:250N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_251():
    result = parse("A*01:251")
    assert result.__class__ is Allele, f'Expected parse("A*01:251") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_252():
    result = parse("A*01:252")
    assert result.__class__ is Allele, f'Expected parse("A*01:252") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_253():
    result = parse("A*01:253")
    assert result.__class__ is Allele, f'Expected parse("A*01:253") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_254():
    result = parse("A*01:254")
    assert result.__class__ is Allele, f'Expected parse("A*01:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_255():
    result = parse("A*01:255")
    assert result.__class__ is Allele, f'Expected parse("A*01:255") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_256():
    result = parse("A*01:256")
    assert result.__class__ is Allele, f'Expected parse("A*01:256") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_257():
    result = parse("A*01:257")
    assert result.__class__ is Allele, f'Expected parse("A*01:257") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_258N():
    result = parse("A*01:258N")
    assert result.__class__ is Allele, f'Expected parse("A*01:258N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:258N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_259():
    result = parse("A*01:259")
    assert result.__class__ is Allele, f'Expected parse("A*01:259") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_26():
    result = parse("A*01:26")
    assert result.__class__ is Allele, f'Expected parse("A*01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_260():
    result = parse("A*01:260")
    assert result.__class__ is Allele, f'Expected parse("A*01:260") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_261():
    result = parse("A*01:261")
    assert result.__class__ is Allele, f'Expected parse("A*01:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_262():
    result = parse("A*01:262")
    assert result.__class__ is Allele, f'Expected parse("A*01:262") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_263():
    result = parse("A*01:263")
    assert result.__class__ is Allele, f'Expected parse("A*01:263") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_264():
    result = parse("A*01:264")
    assert result.__class__ is Allele, f'Expected parse("A*01:264") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_265():
    result = parse("A*01:265")
    assert result.__class__ is Allele, f'Expected parse("A*01:265") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_266_01():
    result = parse("A*01:266:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:266:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:266:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_266_02():
    result = parse("A*01:266:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:266:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:266:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_267():
    result = parse("A*01:267")
    assert result.__class__ is Allele, f'Expected parse("A*01:267") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_268():
    result = parse("A*01:268")
    assert result.__class__ is Allele, f'Expected parse("A*01:268") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_269N():
    result = parse("A*01:269N")
    assert result.__class__ is Allele, f'Expected parse("A*01:269N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:269N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_270():
    result = parse("A*01:270")
    assert result.__class__ is Allele, f'Expected parse("A*01:270") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_271():
    result = parse("A*01:271")
    assert result.__class__ is Allele, f'Expected parse("A*01:271") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_272():
    result = parse("A*01:272")
    assert result.__class__ is Allele, f'Expected parse("A*01:272") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_273():
    result = parse("A*01:273")
    assert result.__class__ is Allele, f'Expected parse("A*01:273") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_274():
    result = parse("A*01:274")
    assert result.__class__ is Allele, f'Expected parse("A*01:274") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_275():
    result = parse("A*01:275")
    assert result.__class__ is Allele, f'Expected parse("A*01:275") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_276():
    result = parse("A*01:276")
    assert result.__class__ is Allele, f'Expected parse("A*01:276") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_277():
    result = parse("A*01:277")
    assert result.__class__ is Allele, f'Expected parse("A*01:277") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_278():
    result = parse("A*01:278")
    assert result.__class__ is Allele, f'Expected parse("A*01:278") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_279():
    result = parse("A*01:279")
    assert result.__class__ is Allele, f'Expected parse("A*01:279") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_27N():
    result = parse("A*01:27N")
    assert result.__class__ is Allele, f'Expected parse("A*01:27N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:27N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_28():
    result = parse("A*01:28")
    assert result.__class__ is Allele, f'Expected parse("A*01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_280():
    result = parse("A*01:280")
    assert result.__class__ is Allele, f'Expected parse("A*01:280") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_281Q():
    result = parse("A*01:281Q")
    assert result.__class__ is Allele, f'Expected parse("A*01:281Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:281Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_282():
    result = parse("A*01:282")
    assert result.__class__ is Allele, f'Expected parse("A*01:282") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_283():
    result = parse("A*01:283")
    assert result.__class__ is Allele, f'Expected parse("A*01:283") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_284():
    result = parse("A*01:284")
    assert result.__class__ is Allele, f'Expected parse("A*01:284") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_285N():
    result = parse("A*01:285N")
    assert result.__class__ is Allele, f'Expected parse("A*01:285N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:285N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_286():
    result = parse("A*01:286")
    assert result.__class__ is Allele, f'Expected parse("A*01:286") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_287N():
    result = parse("A*01:287N")
    assert result.__class__ is Allele, f'Expected parse("A*01:287N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:287N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_288():
    result = parse("A*01:288")
    assert result.__class__ is Allele, f'Expected parse("A*01:288") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_289():
    result = parse("A*01:289")
    assert result.__class__ is Allele, f'Expected parse("A*01:289") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_29():
    result = parse("A*01:29")
    assert result.__class__ is Allele, f'Expected parse("A*01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_290N():
    result = parse("A*01:290N")
    assert result.__class__ is Allele, f'Expected parse("A*01:290N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:290N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_291():
    result = parse("A*01:291")
    assert result.__class__ is Allele, f'Expected parse("A*01:291") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_292():
    result = parse("A*01:292")
    assert result.__class__ is Allele, f'Expected parse("A*01:292") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_293N():
    result = parse("A*01:293N")
    assert result.__class__ is Allele, f'Expected parse("A*01:293N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:293N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_294():
    result = parse("A*01:294")
    assert result.__class__ is Allele, f'Expected parse("A*01:294") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_295():
    result = parse("A*01:295")
    assert result.__class__ is Allele, f'Expected parse("A*01:295") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_296():
    result = parse("A*01:296")
    assert result.__class__ is Allele, f'Expected parse("A*01:296") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_297():
    result = parse("A*01:297")
    assert result.__class__ is Allele, f'Expected parse("A*01:297") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_298():
    result = parse("A*01:298")
    assert result.__class__ is Allele, f'Expected parse("A*01:298") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_299():
    result = parse("A*01:299")
    assert result.__class__ is Allele, f'Expected parse("A*01:299") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_30():
    result = parse("A*01:30")
    assert result.__class__ is Allele, f'Expected parse("A*01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_300():
    result = parse("A*01:300")
    assert result.__class__ is Allele, f'Expected parse("A*01:300") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_301Q():
    result = parse("A*01:301Q")
    assert result.__class__ is Allele, f'Expected parse("A*01:301Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:301Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_302():
    result = parse("A*01:302")
    assert result.__class__ is Allele, f'Expected parse("A*01:302") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_303_01():
    result = parse("A*01:303:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:303:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:303:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_303_02():
    result = parse("A*01:303:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:303:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:303:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_304():
    result = parse("A*01:304")
    assert result.__class__ is Allele, f'Expected parse("A*01:304") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:304") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_305():
    result = parse("A*01:305")
    assert result.__class__ is Allele, f'Expected parse("A*01:305") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_306():
    result = parse("A*01:306")
    assert result.__class__ is Allele, f'Expected parse("A*01:306") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:306") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_307():
    result = parse("A*01:307")
    assert result.__class__ is Allele, f'Expected parse("A*01:307") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_308N():
    result = parse("A*01:308N")
    assert result.__class__ is Allele, f'Expected parse("A*01:308N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:308N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_309():
    result = parse("A*01:309")
    assert result.__class__ is Allele, f'Expected parse("A*01:309") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:309") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_310():
    result = parse("A*01:310")
    assert result.__class__ is Allele, f'Expected parse("A*01:310") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:310") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_311():
    result = parse("A*01:311")
    assert result.__class__ is Allele, f'Expected parse("A*01:311") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:311") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_312():
    result = parse("A*01:312")
    assert result.__class__ is Allele, f'Expected parse("A*01:312") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:312") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_313():
    result = parse("A*01:313")
    assert result.__class__ is Allele, f'Expected parse("A*01:313") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:313") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_314():
    result = parse("A*01:314")
    assert result.__class__ is Allele, f'Expected parse("A*01:314") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:314") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_315():
    result = parse("A*01:315")
    assert result.__class__ is Allele, f'Expected parse("A*01:315") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:315") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_316():
    result = parse("A*01:316")
    assert result.__class__ is Allele, f'Expected parse("A*01:316") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:316") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_317():
    result = parse("A*01:317")
    assert result.__class__ is Allele, f'Expected parse("A*01:317") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:317") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_318():
    result = parse("A*01:318")
    assert result.__class__ is Allele, f'Expected parse("A*01:318") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:318") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_319():
    result = parse("A*01:319")
    assert result.__class__ is Allele, f'Expected parse("A*01:319") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_31N():
    result = parse("A*01:31N")
    assert result.__class__ is Allele, f'Expected parse("A*01:31N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:31N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_32():
    result = parse("A*01:32")
    assert result.__class__ is Allele, f'Expected parse("A*01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_320N():
    result = parse("A*01:320N")
    assert result.__class__ is Allele, f'Expected parse("A*01:320N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:320N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_321():
    result = parse("A*01:321")
    assert result.__class__ is Allele, f'Expected parse("A*01:321") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:321") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_322():
    result = parse("A*01:322")
    assert result.__class__ is Allele, f'Expected parse("A*01:322") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:322") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_323():
    result = parse("A*01:323")
    assert result.__class__ is Allele, f'Expected parse("A*01:323") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:323") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_324():
    result = parse("A*01:324")
    assert result.__class__ is Allele, f'Expected parse("A*01:324") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:324") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_325():
    result = parse("A*01:325")
    assert result.__class__ is Allele, f'Expected parse("A*01:325") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:325") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_326N():
    result = parse("A*01:326N")
    assert result.__class__ is Allele, f'Expected parse("A*01:326N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:326N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_327():
    result = parse("A*01:327")
    assert result.__class__ is Allele, f'Expected parse("A*01:327") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:327") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_328N():
    result = parse("A*01:328N")
    assert result.__class__ is Allele, f'Expected parse("A*01:328N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:328N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_329():
    result = parse("A*01:329")
    assert result.__class__ is Allele, f'Expected parse("A*01:329") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:329") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_33():
    result = parse("A*01:33")
    assert result.__class__ is Allele, f'Expected parse("A*01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_330():
    result = parse("A*01:330")
    assert result.__class__ is Allele, f'Expected parse("A*01:330") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:330") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_331N():
    result = parse("A*01:331N")
    assert result.__class__ is Allele, f'Expected parse("A*01:331N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:331N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_332():
    result = parse("A*01:332")
    assert result.__class__ is Allele, f'Expected parse("A*01:332") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:332") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_333():
    result = parse("A*01:333")
    assert result.__class__ is Allele, f'Expected parse("A*01:333") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:333") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_334():
    result = parse("A*01:334")
    assert result.__class__ is Allele, f'Expected parse("A*01:334") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:334") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_335():
    result = parse("A*01:335")
    assert result.__class__ is Allele, f'Expected parse("A*01:335") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:335") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_336N():
    result = parse("A*01:336N")
    assert result.__class__ is Allele, f'Expected parse("A*01:336N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:336N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_337():
    result = parse("A*01:337")
    assert result.__class__ is Allele, f'Expected parse("A*01:337") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:337") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_338():
    result = parse("A*01:338")
    assert result.__class__ is Allele, f'Expected parse("A*01:338") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:338") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_339():
    result = parse("A*01:339")
    assert result.__class__ is Allele, f'Expected parse("A*01:339") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:339") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_340():
    result = parse("A*01:340")
    assert result.__class__ is Allele, f'Expected parse("A*01:340") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:340") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_341():
    result = parse("A*01:341")
    assert result.__class__ is Allele, f'Expected parse("A*01:341") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:341") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_342():
    result = parse("A*01:342")
    assert result.__class__ is Allele, f'Expected parse("A*01:342") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:342") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_343():
    result = parse("A*01:343")
    assert result.__class__ is Allele, f'Expected parse("A*01:343") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:343") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_344():
    result = parse("A*01:344")
    assert result.__class__ is Allele, f'Expected parse("A*01:344") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:344") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_345():
    result = parse("A*01:345")
    assert result.__class__ is Allele, f'Expected parse("A*01:345") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:345") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_346():
    result = parse("A*01:346")
    assert result.__class__ is Allele, f'Expected parse("A*01:346") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:346") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_347():
    result = parse("A*01:347")
    assert result.__class__ is Allele, f'Expected parse("A*01:347") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:347") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_348():
    result = parse("A*01:348")
    assert result.__class__ is Allele, f'Expected parse("A*01:348") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:348") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_35():
    result = parse("A*01:35")
    assert result.__class__ is Allele, f'Expected parse("A*01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_36():
    result = parse("A*01:36")
    assert result.__class__ is Allele, f'Expected parse("A*01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_37_01_01():
    result = parse("A*01:37:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:37:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:37:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_37_01_02():
    result = parse("A*01:37:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:37:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*01:37:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_38():
    result = parse("A*01:38")
    assert result.__class__ is Allele, f'Expected parse("A*01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_39():
    result = parse("A*01:39")
    assert result.__class__ is Allele, f'Expected parse("A*01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_40():
    result = parse("A*01:40")
    assert result.__class__ is Allele, f'Expected parse("A*01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_41():
    result = parse("A*01:41")
    assert result.__class__ is Allele, f'Expected parse("A*01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_42():
    result = parse("A*01:42")
    assert result.__class__ is Allele, f'Expected parse("A*01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_43():
    result = parse("A*01:43")
    assert result.__class__ is Allele, f'Expected parse("A*01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_44():
    result = parse("A*01:44")
    assert result.__class__ is Allele, f'Expected parse("A*01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_45():
    result = parse("A*01:45")
    assert result.__class__ is Allele, f'Expected parse("A*01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_46():
    result = parse("A*01:46")
    assert result.__class__ is Allele, f'Expected parse("A*01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_47():
    result = parse("A*01:47")
    assert result.__class__ is Allele, f'Expected parse("A*01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_48():
    result = parse("A*01:48")
    assert result.__class__ is Allele, f'Expected parse("A*01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_49():
    result = parse("A*01:49")
    assert result.__class__ is Allele, f'Expected parse("A*01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_50():
    result = parse("A*01:50")
    assert result.__class__ is Allele, f'Expected parse("A*01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_51():
    result = parse("A*01:51")
    assert result.__class__ is Allele, f'Expected parse("A*01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_52_01N():
    result = parse("A*01:52:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:52:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:52:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_52_02N():
    result = parse("A*01:52:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*01:52:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:52:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_53N():
    result = parse("A*01:53N")
    assert result.__class__ is Allele, f'Expected parse("A*01:53N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:53N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_54():
    result = parse("A*01:54")
    assert result.__class__ is Allele, f'Expected parse("A*01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_55():
    result = parse("A*01:55")
    assert result.__class__ is Allele, f'Expected parse("A*01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_56N():
    result = parse("A*01:56N")
    assert result.__class__ is Allele, f'Expected parse("A*01:56N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:56N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_57N():
    result = parse("A*01:57N")
    assert result.__class__ is Allele, f'Expected parse("A*01:57N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:57N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_58():
    result = parse("A*01:58")
    assert result.__class__ is Allele, f'Expected parse("A*01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_59():
    result = parse("A*01:59")
    assert result.__class__ is Allele, f'Expected parse("A*01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_60():
    result = parse("A*01:60")
    assert result.__class__ is Allele, f'Expected parse("A*01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_61():
    result = parse("A*01:61")
    assert result.__class__ is Allele, f'Expected parse("A*01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_62():
    result = parse("A*01:62")
    assert result.__class__ is Allele, f'Expected parse("A*01:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_63():
    result = parse("A*01:63")
    assert result.__class__ is Allele, f'Expected parse("A*01:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_64():
    result = parse("A*01:64")
    assert result.__class__ is Allele, f'Expected parse("A*01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_65():
    result = parse("A*01:65")
    assert result.__class__ is Allele, f'Expected parse("A*01:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_66():
    result = parse("A*01:66")
    assert result.__class__ is Allele, f'Expected parse("A*01:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_67_01():
    result = parse("A*01:67:01")
    assert result.__class__ is Allele, f'Expected parse("A*01:67:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:67:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_67_02():
    result = parse("A*01:67:02")
    assert result.__class__ is Allele, f'Expected parse("A*01:67:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:67:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_68():
    result = parse("A*01:68")
    assert result.__class__ is Allele, f'Expected parse("A*01:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_69_01():
    result = parse("A*01:69:01")
    assert result.__class__ is Allele, f'Expected parse("A*01:69:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:69:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_69_02():
    result = parse("A*01:69:02")
    assert result.__class__ is Allele, f'Expected parse("A*01:69:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:69:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_69_03():
    result = parse("A*01:69:03")
    assert result.__class__ is Allele, f'Expected parse("A*01:69:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:69:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_70():
    result = parse("A*01:70")
    assert result.__class__ is Allele, f'Expected parse("A*01:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_71():
    result = parse("A*01:71")
    assert result.__class__ is Allele, f'Expected parse("A*01:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_72():
    result = parse("A*01:72")
    assert result.__class__ is Allele, f'Expected parse("A*01:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_73():
    result = parse("A*01:73")
    assert result.__class__ is Allele, f'Expected parse("A*01:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_74():
    result = parse("A*01:74")
    assert result.__class__ is Allele, f'Expected parse("A*01:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_75():
    result = parse("A*01:75")
    assert result.__class__ is Allele, f'Expected parse("A*01:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_76():
    result = parse("A*01:76")
    assert result.__class__ is Allele, f'Expected parse("A*01:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_77():
    result = parse("A*01:77")
    assert result.__class__ is Allele, f'Expected parse("A*01:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_78():
    result = parse("A*01:78")
    assert result.__class__ is Allele, f'Expected parse("A*01:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_79():
    result = parse("A*01:79")
    assert result.__class__ is Allele, f'Expected parse("A*01:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_80():
    result = parse("A*01:80")
    assert result.__class__ is Allele, f'Expected parse("A*01:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_81():
    result = parse("A*01:81")
    assert result.__class__ is Allele, f'Expected parse("A*01:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_82():
    result = parse("A*01:82")
    assert result.__class__ is Allele, f'Expected parse("A*01:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_83_01():
    result = parse("A*01:83:01")
    assert result.__class__ is Allele, f'Expected parse("A*01:83:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:83:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_83_02():
    result = parse("A*01:83:02")
    assert result.__class__ is Allele, f'Expected parse("A*01:83:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:83:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_84():
    result = parse("A*01:84")
    assert result.__class__ is Allele, f'Expected parse("A*01:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_85():
    result = parse("A*01:85")
    assert result.__class__ is Allele, f'Expected parse("A*01:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_86():
    result = parse("A*01:86")
    assert result.__class__ is Allele, f'Expected parse("A*01:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_87N():
    result = parse("A*01:87N")
    assert result.__class__ is Allele, f'Expected parse("A*01:87N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:87N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_88_01():
    result = parse("A*01:88:01")
    assert result.__class__ is Allele, f'Expected parse("A*01:88:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:88:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_88_02():
    result = parse("A*01:88:02")
    assert result.__class__ is Allele, f'Expected parse("A*01:88:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:88:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_88_03():
    result = parse("A*01:88:03")
    assert result.__class__ is Allele, f'Expected parse("A*01:88:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*01:88:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_89():
    result = parse("A*01:89")
    assert result.__class__ is Allele, f'Expected parse("A*01:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_90():
    result = parse("A*01:90")
    assert result.__class__ is Allele, f'Expected parse("A*01:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_91():
    result = parse("A*01:91")
    assert result.__class__ is Allele, f'Expected parse("A*01:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_92():
    result = parse("A*01:92")
    assert result.__class__ is Allele, f'Expected parse("A*01:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_93():
    result = parse("A*01:93")
    assert result.__class__ is Allele, f'Expected parse("A*01:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_94():
    result = parse("A*01:94")
    assert result.__class__ is Allele, f'Expected parse("A*01:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_95():
    result = parse("A*01:95")
    assert result.__class__ is Allele, f'Expected parse("A*01:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_96():
    result = parse("A*01:96")
    assert result.__class__ is Allele, f'Expected parse("A*01:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_97():
    result = parse("A*01:97")
    assert result.__class__ is Allele, f'Expected parse("A*01:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_98():
    result = parse("A*01:98")
    assert result.__class__ is Allele, f'Expected parse("A*01:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_01_99():
    result = parse("A*01:99")
    assert result.__class__ is Allele, f'Expected parse("A*01:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*01:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_01():
    result = parse("A*02:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_02L():
    result = parse("A*02:01:01:02L")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:02L") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:02L") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_03():
    result = parse("A*02:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_04():
    result = parse("A*02:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_05():
    result = parse("A*02:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_06():
    result = parse("A*02:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_07():
    result = parse("A*02:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_08():
    result = parse("A*02:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_09():
    result = parse("A*02:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_10():
    result = parse("A*02:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_100():
    result = parse("A*02:01:01:100")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:100") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_101():
    result = parse("A*02:01:01:101")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:101") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_102():
    result = parse("A*02:01:01:102")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:102") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_103():
    result = parse("A*02:01:01:103")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:103") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_104():
    result = parse("A*02:01:01:104")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:104") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_105():
    result = parse("A*02:01:01:105")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:105") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_106():
    result = parse("A*02:01:01:106")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:106") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_107():
    result = parse("A*02:01:01:107")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:107") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_108():
    result = parse("A*02:01:01:108")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:108") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_109():
    result = parse("A*02:01:01:109")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:109") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_11():
    result = parse("A*02:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_110():
    result = parse("A*02:01:01:110")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:110") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_111():
    result = parse("A*02:01:01:111")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:111") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_112():
    result = parse("A*02:01:01:112")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:112") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_113():
    result = parse("A*02:01:01:113")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:113") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_114():
    result = parse("A*02:01:01:114")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:114") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_115():
    result = parse("A*02:01:01:115")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:115") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:115") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_116():
    result = parse("A*02:01:01:116")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:116") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_117():
    result = parse("A*02:01:01:117")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:117") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_118():
    result = parse("A*02:01:01:118")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:118") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:118") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_119():
    result = parse("A*02:01:01:119")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:119") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:119") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_12():
    result = parse("A*02:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_120():
    result = parse("A*02:01:01:120")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:120") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:120") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_121():
    result = parse("A*02:01:01:121")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:121") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:121") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_122():
    result = parse("A*02:01:01:122")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:122") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:122") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_123():
    result = parse("A*02:01:01:123")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:123") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:123") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_124():
    result = parse("A*02:01:01:124")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:124") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:124") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_125():
    result = parse("A*02:01:01:125")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:125") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:125") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_126():
    result = parse("A*02:01:01:126")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:126") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:126") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_127():
    result = parse("A*02:01:01:127")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:127") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:127") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_128():
    result = parse("A*02:01:01:128")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:128") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:128") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_129():
    result = parse("A*02:01:01:129")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:129") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:129") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_13():
    result = parse("A*02:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_130():
    result = parse("A*02:01:01:130")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:130") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:130") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_131():
    result = parse("A*02:01:01:131")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:131") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:131") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_132():
    result = parse("A*02:01:01:132")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:132") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:132") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_133():
    result = parse("A*02:01:01:133")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:133") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:133") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_134Q():
    result = parse("A*02:01:01:134Q")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:134Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:134Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_135():
    result = parse("A*02:01:01:135")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:135") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:135") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_136():
    result = parse("A*02:01:01:136")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:136") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:136") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_137():
    result = parse("A*02:01:01:137")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:137") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:137") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_138():
    result = parse("A*02:01:01:138")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:138") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:138") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_139():
    result = parse("A*02:01:01:139")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:139") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:139") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_14():
    result = parse("A*02:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_140():
    result = parse("A*02:01:01:140")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:140") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:140") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_141():
    result = parse("A*02:01:01:141")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:141") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:141") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_142():
    result = parse("A*02:01:01:142")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:142") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:142") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_143():
    result = parse("A*02:01:01:143")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:143") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:143") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_144():
    result = parse("A*02:01:01:144")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:144") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:144") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_145():
    result = parse("A*02:01:01:145")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:145") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:145") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_146():
    result = parse("A*02:01:01:146")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:146") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:146") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_147():
    result = parse("A*02:01:01:147")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:147") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:147") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_148():
    result = parse("A*02:01:01:148")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:148") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:148") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_149():
    result = parse("A*02:01:01:149")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:149") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:149") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_15():
    result = parse("A*02:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_150():
    result = parse("A*02:01:01:150")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:150") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:150") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_16():
    result = parse("A*02:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_17():
    result = parse("A*02:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_18():
    result = parse("A*02:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_19():
    result = parse("A*02:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_20():
    result = parse("A*02:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_21():
    result = parse("A*02:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_22():
    result = parse("A*02:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_23():
    result = parse("A*02:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_24():
    result = parse("A*02:01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_25():
    result = parse("A*02:01:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_26():
    result = parse("A*02:01:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_27():
    result = parse("A*02:01:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_28():
    result = parse("A*02:01:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_29():
    result = parse("A*02:01:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_30():
    result = parse("A*02:01:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_31():
    result = parse("A*02:01:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_32():
    result = parse("A*02:01:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_33():
    result = parse("A*02:01:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_34():
    result = parse("A*02:01:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_35():
    result = parse("A*02:01:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_36():
    result = parse("A*02:01:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_37():
    result = parse("A*02:01:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_38():
    result = parse("A*02:01:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_39():
    result = parse("A*02:01:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_40():
    result = parse("A*02:01:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_41():
    result = parse("A*02:01:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_42():
    result = parse("A*02:01:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_43():
    result = parse("A*02:01:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_44():
    result = parse("A*02:01:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_45():
    result = parse("A*02:01:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:45") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_46():
    result = parse("A*02:01:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:46") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_47():
    result = parse("A*02:01:01:47")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:47") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_48():
    result = parse("A*02:01:01:48")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:48") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:48") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_49():
    result = parse("A*02:01:01:49")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:49") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:49") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_50():
    result = parse("A*02:01:01:50")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:50") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:50") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_51():
    result = parse("A*02:01:01:51")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:51") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:51") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_52():
    result = parse("A*02:01:01:52")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:52") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:52") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_53():
    result = parse("A*02:01:01:53")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:53") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:53") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_54():
    result = parse("A*02:01:01:54")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:54") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:54") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_55():
    result = parse("A*02:01:01:55")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:55") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:55") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_56():
    result = parse("A*02:01:01:56")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:56") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:56") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_57():
    result = parse("A*02:01:01:57")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:57") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:57") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_58():
    result = parse("A*02:01:01:58")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:58") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:58") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_59():
    result = parse("A*02:01:01:59")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:59") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:59") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_60():
    result = parse("A*02:01:01:60")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:60") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:60") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_61():
    result = parse("A*02:01:01:61")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:61") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:61") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_62():
    result = parse("A*02:01:01:62")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:62") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:62") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_63():
    result = parse("A*02:01:01:63")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:63") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:63") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_64():
    result = parse("A*02:01:01:64")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:64") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:64") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_65():
    result = parse("A*02:01:01:65")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:65") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:65") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_66():
    result = parse("A*02:01:01:66")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:66") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:66") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_67():
    result = parse("A*02:01:01:67")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:67") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:67") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_68():
    result = parse("A*02:01:01:68")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:68") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:68") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_69():
    result = parse("A*02:01:01:69")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:69") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:69") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_70():
    result = parse("A*02:01:01:70")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:70") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:70") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_71():
    result = parse("A*02:01:01:71")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:71") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:71") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_72():
    result = parse("A*02:01:01:72")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:72") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:72") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_73():
    result = parse("A*02:01:01:73")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:73") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:73") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_74():
    result = parse("A*02:01:01:74")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:74") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:74") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_75():
    result = parse("A*02:01:01:75")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:75") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:75") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_76():
    result = parse("A*02:01:01:76")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:76") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:76") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_77():
    result = parse("A*02:01:01:77")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:77") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:77") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_78():
    result = parse("A*02:01:01:78")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:78") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:78") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_79():
    result = parse("A*02:01:01:79")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:79") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:79") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_80():
    result = parse("A*02:01:01:80")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:80") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:80") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_81():
    result = parse("A*02:01:01:81")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:81") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:81") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_82():
    result = parse("A*02:01:01:82")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:82") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:82") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_83():
    result = parse("A*02:01:01:83")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:83") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:83") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_84():
    result = parse("A*02:01:01:84")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:84") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:84") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_85():
    result = parse("A*02:01:01:85")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:85") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:85") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_86():
    result = parse("A*02:01:01:86")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:86") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:86") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_87():
    result = parse("A*02:01:01:87")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:87") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:87") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_88():
    result = parse("A*02:01:01:88")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:88") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:88") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_89():
    result = parse("A*02:01:01:89")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:89") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:89") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_90():
    result = parse("A*02:01:01:90")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:90") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:90") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_91():
    result = parse("A*02:01:01:91")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:91") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:91") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_92():
    result = parse("A*02:01:01:92")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:92") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:92") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_93():
    result = parse("A*02:01:01:93")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:93") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:93") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_94():
    result = parse("A*02:01:01:94")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:94") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:94") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_95():
    result = parse("A*02:01:01:95")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:95") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:95") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_96():
    result = parse("A*02:01:01:96")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:96") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:96") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_97():
    result = parse("A*02:01:01:97")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:97") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:97") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_98():
    result = parse("A*02:01:01:98")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:98") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:98") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_01_99():
    result = parse("A*02:01:01:99")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:01:99") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:01:99") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_02_01():
    result = parse("A*02:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_02_02():
    result = parse("A*02:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_03():
    result = parse("A*02:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_04():
    result = parse("A*02:01:04")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_05():
    result = parse("A*02:01:05")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_06():
    result = parse("A*02:01:06")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_07():
    result = parse("A*02:01:07")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_08():
    result = parse("A*02:01:08")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_09():
    result = parse("A*02:01:09")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_10():
    result = parse("A*02:01:10")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_100():
    result = parse("A*02:01:100")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:100") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_101():
    result = parse("A*02:01:101")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:101") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_102():
    result = parse("A*02:01:102")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:102") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_103():
    result = parse("A*02:01:103")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:103") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_104():
    result = parse("A*02:01:104")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:104") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_105():
    result = parse("A*02:01:105")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:105") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_106():
    result = parse("A*02:01:106")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:106") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_107():
    result = parse("A*02:01:107")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:107") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_108():
    result = parse("A*02:01:108")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:108") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_109():
    result = parse("A*02:01:109")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:109") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_11():
    result = parse("A*02:01:11")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_110():
    result = parse("A*02:01:110")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:110") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_111():
    result = parse("A*02:01:111")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:111") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_112():
    result = parse("A*02:01:112")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:112") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_113():
    result = parse("A*02:01:113")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:113") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_114():
    result = parse("A*02:01:114")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:114") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_115():
    result = parse("A*02:01:115")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:115") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:115") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_116():
    result = parse("A*02:01:116")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:116") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_117():
    result = parse("A*02:01:117")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:117") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_118():
    result = parse("A*02:01:118")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:118") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:118") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_119():
    result = parse("A*02:01:119")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:119") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:119") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_12():
    result = parse("A*02:01:12")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_120():
    result = parse("A*02:01:120")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:120") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:120") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_121():
    result = parse("A*02:01:121")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:121") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:121") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_122():
    result = parse("A*02:01:122")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:122") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:122") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_123():
    result = parse("A*02:01:123")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:123") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:123") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_124():
    result = parse("A*02:01:124")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:124") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:124") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_125():
    result = parse("A*02:01:125")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:125") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:125") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_126():
    result = parse("A*02:01:126")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:126") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:126") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_127():
    result = parse("A*02:01:127")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:127") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:127") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_128():
    result = parse("A*02:01:128")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:128") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:128") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_129():
    result = parse("A*02:01:129")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:129") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:129") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_13():
    result = parse("A*02:01:13")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_130():
    result = parse("A*02:01:130")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:130") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:130") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_131():
    result = parse("A*02:01:131")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:131") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:131") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_132():
    result = parse("A*02:01:132")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:132") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:132") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_133():
    result = parse("A*02:01:133")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:133") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:133") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_134():
    result = parse("A*02:01:134")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:134") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:134") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_135():
    result = parse("A*02:01:135")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:135") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:135") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_136():
    result = parse("A*02:01:136")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:136") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:136") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_137():
    result = parse("A*02:01:137")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:137") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:137") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_138():
    result = parse("A*02:01:138")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:138") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:138") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_139():
    result = parse("A*02:01:139")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:139") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:139") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_140():
    result = parse("A*02:01:140")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:140") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:140") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_141():
    result = parse("A*02:01:141")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:141") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:141") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_142():
    result = parse("A*02:01:142")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:142") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:142") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_143():
    result = parse("A*02:01:143")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:143") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:143") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_144():
    result = parse("A*02:01:144")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:144") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:144") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_145():
    result = parse("A*02:01:145")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:145") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:145") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_146():
    result = parse("A*02:01:146")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:146") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:146") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_147():
    result = parse("A*02:01:147")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:147") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:147") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_148():
    result = parse("A*02:01:148")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:148") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:148") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_149():
    result = parse("A*02:01:149")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:149") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:149") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_14Q():
    result = parse("A*02:01:14Q")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:14Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:14Q") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_15():
    result = parse("A*02:01:15")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_150():
    result = parse("A*02:01:150")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:150") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:150") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_151():
    result = parse("A*02:01:151")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:151") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:151") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_152():
    result = parse("A*02:01:152")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:152") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:152") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_153():
    result = parse("A*02:01:153")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:153") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:153") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_154():
    result = parse("A*02:01:154")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:154") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:154") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_155():
    result = parse("A*02:01:155")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:155") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:155") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_156():
    result = parse("A*02:01:156")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:156") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:156") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_157():
    result = parse("A*02:01:157")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:157") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:157") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_158():
    result = parse("A*02:01:158")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:158") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:158") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_159():
    result = parse("A*02:01:159")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:159") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:159") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_160():
    result = parse("A*02:01:160")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:160") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:160") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_161():
    result = parse("A*02:01:161")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:161") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:161") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_162():
    result = parse("A*02:01:162")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:162") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:162") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_163():
    result = parse("A*02:01:163")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:163") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:163") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_164():
    result = parse("A*02:01:164")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:164") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:164") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_165():
    result = parse("A*02:01:165")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:165") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:165") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_166():
    result = parse("A*02:01:166")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:166") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:166") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_167():
    result = parse("A*02:01:167")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:167") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:167") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_168():
    result = parse("A*02:01:168")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:168") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:168") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_169():
    result = parse("A*02:01:169")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:169") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:169") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_17():
    result = parse("A*02:01:17")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_170():
    result = parse("A*02:01:170")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:170") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:170") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_171():
    result = parse("A*02:01:171")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:171") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:171") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_172():
    result = parse("A*02:01:172")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:172") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:172") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_173():
    result = parse("A*02:01:173")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:173") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:173") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_174():
    result = parse("A*02:01:174")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:174") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:174") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_175():
    result = parse("A*02:01:175")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:175") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:175") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_176():
    result = parse("A*02:01:176")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:176") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:176") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_177():
    result = parse("A*02:01:177")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:177") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:177") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_178():
    result = parse("A*02:01:178")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:178") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:178") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_179():
    result = parse("A*02:01:179")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:179") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:179") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_18():
    result = parse("A*02:01:18")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_180():
    result = parse("A*02:01:180")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:180") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:180") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_181():
    result = parse("A*02:01:181")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:01:181") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:181") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_19():
    result = parse("A*02:01:19")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_21():
    result = parse("A*02:01:21")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_22():
    result = parse("A*02:01:22")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_23():
    result = parse("A*02:01:23")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_24():
    result = parse("A*02:01:24")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_25():
    result = parse("A*02:01:25")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_26():
    result = parse("A*02:01:26")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_27():
    result = parse("A*02:01:27")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_28():
    result = parse("A*02:01:28")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_29():
    result = parse("A*02:01:29")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_30():
    result = parse("A*02:01:30")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_31():
    result = parse("A*02:01:31")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_32():
    result = parse("A*02:01:32")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_33():
    result = parse("A*02:01:33")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_34():
    result = parse("A*02:01:34")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_35():
    result = parse("A*02:01:35")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_36():
    result = parse("A*02:01:36")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_37():
    result = parse("A*02:01:37")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_38():
    result = parse("A*02:01:38")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_39():
    result = parse("A*02:01:39")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_40():
    result = parse("A*02:01:40")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_41():
    result = parse("A*02:01:41")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_42():
    result = parse("A*02:01:42")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_43():
    result = parse("A*02:01:43")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_44():
    result = parse("A*02:01:44")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_45():
    result = parse("A*02:01:45")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_46():
    result = parse("A*02:01:46")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_47():
    result = parse("A*02:01:47")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_48():
    result = parse("A*02:01:48")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_49():
    result = parse("A*02:01:49")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_50():
    result = parse("A*02:01:50")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_51():
    result = parse("A*02:01:51")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_52():
    result = parse("A*02:01:52")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_53():
    result = parse("A*02:01:53")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_54():
    result = parse("A*02:01:54")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_55():
    result = parse("A*02:01:55")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_56():
    result = parse("A*02:01:56")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_57():
    result = parse("A*02:01:57")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_58():
    result = parse("A*02:01:58")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_59():
    result = parse("A*02:01:59")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_60():
    result = parse("A*02:01:60")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_61():
    result = parse("A*02:01:61")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_62():
    result = parse("A*02:01:62")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_63():
    result = parse("A*02:01:63")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_64():
    result = parse("A*02:01:64")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_65():
    result = parse("A*02:01:65")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_66():
    result = parse("A*02:01:66")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:66") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:66") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_67():
    result = parse("A*02:01:67")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:67") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:67") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_68():
    result = parse("A*02:01:68")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:68") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:68") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_69():
    result = parse("A*02:01:69")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:69") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:69") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_70():
    result = parse("A*02:01:70")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:70") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:70") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_71():
    result = parse("A*02:01:71")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:71") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:71") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_72():
    result = parse("A*02:01:72")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:72") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:72") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_73():
    result = parse("A*02:01:73")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:73") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:73") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_74():
    result = parse("A*02:01:74")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:74") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:74") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_75():
    result = parse("A*02:01:75")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:75") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:75") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_76():
    result = parse("A*02:01:76")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:76") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:76") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_77():
    result = parse("A*02:01:77")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:77") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:77") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_78():
    result = parse("A*02:01:78")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:78") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:78") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_79():
    result = parse("A*02:01:79")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:79") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:79") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_80():
    result = parse("A*02:01:80")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:80") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:80") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_81():
    result = parse("A*02:01:81")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:81") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:81") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_83():
    result = parse("A*02:01:83")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:83") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:83") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_84():
    result = parse("A*02:01:84")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:84") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:84") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_85():
    result = parse("A*02:01:85")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:85") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:85") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_86():
    result = parse("A*02:01:86")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:86") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:86") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_87():
    result = parse("A*02:01:87")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:87") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:87") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_88():
    result = parse("A*02:01:88")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:88") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:88") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_89():
    result = parse("A*02:01:89")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:89") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:89") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_90():
    result = parse("A*02:01:90")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:90") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:90") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_91():
    result = parse("A*02:01:91")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:91") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:91") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_92():
    result = parse("A*02:01:92")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:92") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:92") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_93():
    result = parse("A*02:01:93")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:93") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:93") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_94():
    result = parse("A*02:01:94")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:94") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:94") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_95():
    result = parse("A*02:01:95")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:95") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:95") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_96():
    result = parse("A*02:01:96")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:96") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:96") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_97():
    result = parse("A*02:01:97")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:97") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:97") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_98():
    result = parse("A*02:01:98")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:98") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:98") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_01_99():
    result = parse("A*02:01:99")
    assert result.__class__ is Allele, f'Expected parse("A*02:01:99") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:01:99") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_02_01_01():
    result = parse("A*02:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_02_01_02():
    result = parse("A*02:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_02_01_03():
    result = parse("A*02:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_02_01_04():
    result = parse("A*02:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_02_01_05():
    result = parse("A*02:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_02_01_06():
    result = parse("A*02:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_02_02():
    result = parse("A*02:02:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_02_03():
    result = parse("A*02:02:03")
    assert result.__class__ is Allele, f'Expected parse("A*02:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_02_04():
    result = parse("A*02:02:04")
    assert result.__class__ is Allele, f'Expected parse("A*02:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_02_05():
    result = parse("A*02:02:05")
    assert result.__class__ is Allele, f'Expected parse("A*02:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_02_06():
    result = parse("A*02:02:06")
    assert result.__class__ is Allele, f'Expected parse("A*02:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_03_01():
    result = parse("A*02:03:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:03:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:03:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_03_02():
    result = parse("A*02:03:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_03_03():
    result = parse("A*02:03:03")
    assert result.__class__ is Allele, f'Expected parse("A*02:03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_03_04():
    result = parse("A*02:03:04")
    assert result.__class__ is Allele, f'Expected parse("A*02:03:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_03_05():
    result = parse("A*02:03:05")
    assert result.__class__ is Allele, f'Expected parse("A*02:03:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_03_06():
    result = parse("A*02:03:06")
    assert result.__class__ is Allele, f'Expected parse("A*02:03:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_03_07():
    result = parse("A*02:03:07")
    assert result.__class__ is Allele, f'Expected parse("A*02:03:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_03_08():
    result = parse("A*02:03:08")
    assert result.__class__ is Allele, f'Expected parse("A*02:03:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:03:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_03_09():
    result = parse("A*02:03:09")
    assert result.__class__ is Allele, f'Expected parse("A*02:03:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:03:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_03_10():
    result = parse("A*02:03:10")
    assert result.__class__ is Allele, f'Expected parse("A*02:03:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:03:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_04():
    result = parse("A*02:04")
    assert result.__class__ is Allele, f'Expected parse("A*02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_01_01():
    result = parse("A*02:05:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:05:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:05:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_01_02():
    result = parse("A*02:05:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:05:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:05:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_01_03():
    result = parse("A*02:05:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:05:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:05:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_01_04():
    result = parse("A*02:05:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:05:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:05:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_01_05():
    result = parse("A*02:05:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:05:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:05:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_01_06():
    result = parse("A*02:05:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:05:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:05:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_01_07():
    result = parse("A*02:05:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:05:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:05:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_01_08():
    result = parse("A*02:05:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:05:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:05:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_01_09():
    result = parse("A*02:05:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:05:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:05:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_01_10():
    result = parse("A*02:05:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:05:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:05:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_01_11():
    result = parse("A*02:05:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:05:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:05:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_02():
    result = parse("A*02:05:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:05:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_03():
    result = parse("A*02:05:03")
    assert result.__class__ is Allele, f'Expected parse("A*02:05:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:05:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_04():
    result = parse("A*02:05:04")
    assert result.__class__ is Allele, f'Expected parse("A*02:05:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:05:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_05():
    result = parse("A*02:05:05")
    assert result.__class__ is Allele, f'Expected parse("A*02:05:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:05:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_06():
    result = parse("A*02:05:06")
    assert result.__class__ is Allele, f'Expected parse("A*02:05:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:05:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_07():
    result = parse("A*02:05:07")
    assert result.__class__ is Allele, f'Expected parse("A*02:05:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:05:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_08():
    result = parse("A*02:05:08")
    assert result.__class__ is Allele, f'Expected parse("A*02:05:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:05:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_09():
    result = parse("A*02:05:09")
    assert result.__class__ is Allele, f'Expected parse("A*02:05:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:05:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_10():
    result = parse("A*02:05:10")
    assert result.__class__ is Allele, f'Expected parse("A*02:05:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:05:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_11():
    result = parse("A*02:05:11")
    assert result.__class__ is Allele, f'Expected parse("A*02:05:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:05:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_05_12():
    result = parse("A*02:05:12")
    assert result.__class__ is Allele, f'Expected parse("A*02:05:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:05:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_01_01():
    result = parse("A*02:06:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:06:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:06:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_01_02():
    result = parse("A*02:06:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:06:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:06:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_01_03():
    result = parse("A*02:06:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:06:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:06:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_01_04():
    result = parse("A*02:06:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:06:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:06:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_01_05():
    result = parse("A*02:06:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:06:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:06:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_01_06():
    result = parse("A*02:06:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:06:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:06:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_01_07():
    result = parse("A*02:06:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:06:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:06:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_01_08():
    result = parse("A*02:06:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:06:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:06:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_01_09():
    result = parse("A*02:06:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:06:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:06:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_01_10():
    result = parse("A*02:06:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:06:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:06:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_01_11():
    result = parse("A*02:06:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:06:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:06:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_01_12():
    result = parse("A*02:06:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:06:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:06:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_02():
    result = parse("A*02:06:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_03():
    result = parse("A*02:06:03")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_04():
    result = parse("A*02:06:04")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_05():
    result = parse("A*02:06:05")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_06():
    result = parse("A*02:06:06")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_07():
    result = parse("A*02:06:07")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_08():
    result = parse("A*02:06:08")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_09():
    result = parse("A*02:06:09")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_10():
    result = parse("A*02:06:10")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_11():
    result = parse("A*02:06:11")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_12():
    result = parse("A*02:06:12")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_13():
    result = parse("A*02:06:13")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_14():
    result = parse("A*02:06:14")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_15():
    result = parse("A*02:06:15")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_16():
    result = parse("A*02:06:16")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_17():
    result = parse("A*02:06:17")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_18():
    result = parse("A*02:06:18")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_19():
    result = parse("A*02:06:19")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_20():
    result = parse("A*02:06:20")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_21():
    result = parse("A*02:06:21")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_22():
    result = parse("A*02:06:22")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_23():
    result = parse("A*02:06:23")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_24():
    result = parse("A*02:06:24")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_25():
    result = parse("A*02:06:25")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_26():
    result = parse("A*02:06:26")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_27():
    result = parse("A*02:06:27")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_28():
    result = parse("A*02:06:28")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_06_29():
    result = parse("A*02:06:29")
    assert result.__class__ is Allele, f'Expected parse("A*02:06:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:06:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_01_01():
    result = parse("A*02:07:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:07:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:07:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_01_02():
    result = parse("A*02:07:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:07:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:07:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_02():
    result = parse("A*02:07:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:07:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_03():
    result = parse("A*02:07:03")
    assert result.__class__ is Allele, f'Expected parse("A*02:07:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:07:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_04():
    result = parse("A*02:07:04")
    assert result.__class__ is Allele, f'Expected parse("A*02:07:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:07:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_05():
    result = parse("A*02:07:05")
    assert result.__class__ is Allele, f'Expected parse("A*02:07:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:07:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_06():
    result = parse("A*02:07:06")
    assert result.__class__ is Allele, f'Expected parse("A*02:07:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:07:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_07():
    result = parse("A*02:07:07")
    assert result.__class__ is Allele, f'Expected parse("A*02:07:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:07:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_08():
    result = parse("A*02:07:08")
    assert result.__class__ is Allele, f'Expected parse("A*02:07:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:07:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_09():
    result = parse("A*02:07:09")
    assert result.__class__ is Allele, f'Expected parse("A*02:07:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:07:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_10():
    result = parse("A*02:07:10")
    assert result.__class__ is Allele, f'Expected parse("A*02:07:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:07:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_11():
    result = parse("A*02:07:11")
    assert result.__class__ is Allele, f'Expected parse("A*02:07:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:07:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_12():
    result = parse("A*02:07:12")
    assert result.__class__ is Allele, f'Expected parse("A*02:07:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:07:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_13():
    result = parse("A*02:07:13")
    assert result.__class__ is Allele, f'Expected parse("A*02:07:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:07:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_14():
    result = parse("A*02:07:14")
    assert result.__class__ is Allele, f'Expected parse("A*02:07:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:07:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_15():
    result = parse("A*02:07:15")
    assert result.__class__ is Allele, f'Expected parse("A*02:07:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:07:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_16():
    result = parse("A*02:07:16")
    assert result.__class__ is Allele, f'Expected parse("A*02:07:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:07:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_07_17():
    result = parse("A*02:07:17")
    assert result.__class__ is Allele, f'Expected parse("A*02:07:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:07:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_08():
    result = parse("A*02:08")
    assert result.__class__ is Allele, f'Expected parse("A*02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_09_01_01():
    result = parse("A*02:09:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:09:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:09:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_09_01_02():
    result = parse("A*02:09:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:09:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:09:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_10():
    result = parse("A*02:10")
    assert result.__class__ is Allele, f'Expected parse("A*02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_101_01():
    result = parse("A*02:101:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:101:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:101:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_101_02():
    result = parse("A*02:101:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:101:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:101:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_102():
    result = parse("A*02:102")
    assert result.__class__ is Allele, f'Expected parse("A*02:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_103():
    result = parse("A*02:103")
    assert result.__class__ is Allele, f'Expected parse("A*02:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_104():
    result = parse("A*02:104")
    assert result.__class__ is Allele, f'Expected parse("A*02:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_105():
    result = parse("A*02:105")
    assert result.__class__ is Allele, f'Expected parse("A*02:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_106():
    result = parse("A*02:106")
    assert result.__class__ is Allele, f'Expected parse("A*02:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_107():
    result = parse("A*02:107")
    assert result.__class__ is Allele, f'Expected parse("A*02:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_108():
    result = parse("A*02:108")
    assert result.__class__ is Allele, f'Expected parse("A*02:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_109():
    result = parse("A*02:109")
    assert result.__class__ is Allele, f'Expected parse("A*02:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_110():
    result = parse("A*02:110")
    assert result.__class__ is Allele, f'Expected parse("A*02:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_111():
    result = parse("A*02:111")
    assert result.__class__ is Allele, f'Expected parse("A*02:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_112():
    result = parse("A*02:112")
    assert result.__class__ is Allele, f'Expected parse("A*02:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_113_01N():
    result = parse("A*02:113:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:113:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:113:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_113_02N():
    result = parse("A*02:113:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:113:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:113:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_114():
    result = parse("A*02:114")
    assert result.__class__ is Allele, f'Expected parse("A*02:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_115():
    result = parse("A*02:115")
    assert result.__class__ is Allele, f'Expected parse("A*02:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_116():
    result = parse("A*02:116")
    assert result.__class__ is Allele, f'Expected parse("A*02:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_117():
    result = parse("A*02:117")
    assert result.__class__ is Allele, f'Expected parse("A*02:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_118():
    result = parse("A*02:118")
    assert result.__class__ is Allele, f'Expected parse("A*02:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_119():
    result = parse("A*02:119")
    assert result.__class__ is Allele, f'Expected parse("A*02:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_11_01_01():
    result = parse("A*02:11:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:11:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:11:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_11_01_02():
    result = parse("A*02:11:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:11:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:11:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_11_01_03():
    result = parse("A*02:11:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:11:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:11:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_11_02():
    result = parse("A*02:11:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:11:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:11:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_11_03():
    result = parse("A*02:11:03")
    assert result.__class__ is Allele, f'Expected parse("A*02:11:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:11:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_11_04():
    result = parse("A*02:11:04")
    assert result.__class__ is Allele, f'Expected parse("A*02:11:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:11:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_11_05():
    result = parse("A*02:11:05")
    assert result.__class__ is Allele, f'Expected parse("A*02:11:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:11:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_11_06():
    result = parse("A*02:11:06")
    assert result.__class__ is Allele, f'Expected parse("A*02:11:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:11:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_11_07():
    result = parse("A*02:11:07")
    assert result.__class__ is Allele, f'Expected parse("A*02:11:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:11:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_11_08():
    result = parse("A*02:11:08")
    assert result.__class__ is Allele, f'Expected parse("A*02:11:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:11:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_11_09():
    result = parse("A*02:11:09")
    assert result.__class__ is Allele, f'Expected parse("A*02:11:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:11:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_12():
    result = parse("A*02:12")
    assert result.__class__ is Allele, f'Expected parse("A*02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_120():
    result = parse("A*02:120")
    assert result.__class__ is Allele, f'Expected parse("A*02:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_121():
    result = parse("A*02:121")
    assert result.__class__ is Allele, f'Expected parse("A*02:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_122():
    result = parse("A*02:122")
    assert result.__class__ is Allele, f'Expected parse("A*02:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_123():
    result = parse("A*02:123")
    assert result.__class__ is Allele, f'Expected parse("A*02:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_124():
    result = parse("A*02:124")
    assert result.__class__ is Allele, f'Expected parse("A*02:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_125N():
    result = parse("A*02:125N")
    assert result.__class__ is Allele, f'Expected parse("A*02:125N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:125N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_126():
    result = parse("A*02:126")
    assert result.__class__ is Allele, f'Expected parse("A*02:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_127():
    result = parse("A*02:127")
    assert result.__class__ is Allele, f'Expected parse("A*02:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_128():
    result = parse("A*02:128")
    assert result.__class__ is Allele, f'Expected parse("A*02:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_129():
    result = parse("A*02:129")
    assert result.__class__ is Allele, f'Expected parse("A*02:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_13():
    result = parse("A*02:13")
    assert result.__class__ is Allele, f'Expected parse("A*02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_130():
    result = parse("A*02:130")
    assert result.__class__ is Allele, f'Expected parse("A*02:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_131_01_01():
    result = parse("A*02:131:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:131:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:131:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_131_01_02():
    result = parse("A*02:131:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:131:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:131:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_131_01_03():
    result = parse("A*02:131:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:131:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:131:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_131_02():
    result = parse("A*02:131:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:131:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:131:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_132():
    result = parse("A*02:132")
    assert result.__class__ is Allele, f'Expected parse("A*02:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_133():
    result = parse("A*02:133")
    assert result.__class__ is Allele, f'Expected parse("A*02:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_134():
    result = parse("A*02:134")
    assert result.__class__ is Allele, f'Expected parse("A*02:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_135():
    result = parse("A*02:135")
    assert result.__class__ is Allele, f'Expected parse("A*02:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_136():
    result = parse("A*02:136")
    assert result.__class__ is Allele, f'Expected parse("A*02:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_137():
    result = parse("A*02:137")
    assert result.__class__ is Allele, f'Expected parse("A*02:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_138():
    result = parse("A*02:138")
    assert result.__class__ is Allele, f'Expected parse("A*02:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_139():
    result = parse("A*02:139")
    assert result.__class__ is Allele, f'Expected parse("A*02:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_14():
    result = parse("A*02:14")
    assert result.__class__ is Allele, f'Expected parse("A*02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_140():
    result = parse("A*02:140")
    assert result.__class__ is Allele, f'Expected parse("A*02:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_141():
    result = parse("A*02:141")
    assert result.__class__ is Allele, f'Expected parse("A*02:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_142():
    result = parse("A*02:142")
    assert result.__class__ is Allele, f'Expected parse("A*02:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_143():
    result = parse("A*02:143")
    assert result.__class__ is Allele, f'Expected parse("A*02:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_144():
    result = parse("A*02:144")
    assert result.__class__ is Allele, f'Expected parse("A*02:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_145():
    result = parse("A*02:145")
    assert result.__class__ is Allele, f'Expected parse("A*02:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_146():
    result = parse("A*02:146")
    assert result.__class__ is Allele, f'Expected parse("A*02:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_147():
    result = parse("A*02:147")
    assert result.__class__ is Allele, f'Expected parse("A*02:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_148():
    result = parse("A*02:148")
    assert result.__class__ is Allele, f'Expected parse("A*02:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_149():
    result = parse("A*02:149")
    assert result.__class__ is Allele, f'Expected parse("A*02:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_150_01():
    result = parse("A*02:150:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:150:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:150:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_150_02():
    result = parse("A*02:150:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:150:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:150:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_151():
    result = parse("A*02:151")
    assert result.__class__ is Allele, f'Expected parse("A*02:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_152():
    result = parse("A*02:152")
    assert result.__class__ is Allele, f'Expected parse("A*02:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_153_01():
    result = parse("A*02:153:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:153:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:153:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_153_02():
    result = parse("A*02:153:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:153:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:153:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_154():
    result = parse("A*02:154")
    assert result.__class__ is Allele, f'Expected parse("A*02:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_155():
    result = parse("A*02:155")
    assert result.__class__ is Allele, f'Expected parse("A*02:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_156():
    result = parse("A*02:156")
    assert result.__class__ is Allele, f'Expected parse("A*02:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_157_01():
    result = parse("A*02:157:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:157:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:157:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_157_02():
    result = parse("A*02:157:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:157:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:157:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_158():
    result = parse("A*02:158")
    assert result.__class__ is Allele, f'Expected parse("A*02:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_159():
    result = parse("A*02:159")
    assert result.__class__ is Allele, f'Expected parse("A*02:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_15N():
    result = parse("A*02:15N")
    assert result.__class__ is Allele, f'Expected parse("A*02:15N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:15N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_16():
    result = parse("A*02:16")
    assert result.__class__ is Allele, f'Expected parse("A*02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_160():
    result = parse("A*02:160")
    assert result.__class__ is Allele, f'Expected parse("A*02:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_161():
    result = parse("A*02:161")
    assert result.__class__ is Allele, f'Expected parse("A*02:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_162():
    result = parse("A*02:162")
    assert result.__class__ is Allele, f'Expected parse("A*02:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_163():
    result = parse("A*02:163")
    assert result.__class__ is Allele, f'Expected parse("A*02:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_164_01():
    result = parse("A*02:164:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:164:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:164:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_164_02():
    result = parse("A*02:164:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:164:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:164:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_165():
    result = parse("A*02:165")
    assert result.__class__ is Allele, f'Expected parse("A*02:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_166():
    result = parse("A*02:166")
    assert result.__class__ is Allele, f'Expected parse("A*02:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_167():
    result = parse("A*02:167")
    assert result.__class__ is Allele, f'Expected parse("A*02:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_168():
    result = parse("A*02:168")
    assert result.__class__ is Allele, f'Expected parse("A*02:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_169():
    result = parse("A*02:169")
    assert result.__class__ is Allele, f'Expected parse("A*02:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_170():
    result = parse("A*02:170")
    assert result.__class__ is Allele, f'Expected parse("A*02:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_171_01():
    result = parse("A*02:171:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:171:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:171:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_171_02():
    result = parse("A*02:171:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:171:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:171:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_172():
    result = parse("A*02:172")
    assert result.__class__ is Allele, f'Expected parse("A*02:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_173():
    result = parse("A*02:173")
    assert result.__class__ is Allele, f'Expected parse("A*02:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_174():
    result = parse("A*02:174")
    assert result.__class__ is Allele, f'Expected parse("A*02:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_175():
    result = parse("A*02:175")
    assert result.__class__ is Allele, f'Expected parse("A*02:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_176():
    result = parse("A*02:176")
    assert result.__class__ is Allele, f'Expected parse("A*02:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_177():
    result = parse("A*02:177")
    assert result.__class__ is Allele, f'Expected parse("A*02:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_178():
    result = parse("A*02:178")
    assert result.__class__ is Allele, f'Expected parse("A*02:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_179():
    result = parse("A*02:179")
    assert result.__class__ is Allele, f'Expected parse("A*02:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_17_02_01():
    result = parse("A*02:17:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:17:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:17:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_17_02_02():
    result = parse("A*02:17:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:17:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:17:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_17_03():
    result = parse("A*02:17:03")
    assert result.__class__ is Allele, f'Expected parse("A*02:17:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:17:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_17_04():
    result = parse("A*02:17:04")
    assert result.__class__ is Allele, f'Expected parse("A*02:17:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:17:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_18():
    result = parse("A*02:18")
    assert result.__class__ is Allele, f'Expected parse("A*02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_180():
    result = parse("A*02:180")
    assert result.__class__ is Allele, f'Expected parse("A*02:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_181():
    result = parse("A*02:181")
    assert result.__class__ is Allele, f'Expected parse("A*02:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_182():
    result = parse("A*02:182")
    assert result.__class__ is Allele, f'Expected parse("A*02:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_183():
    result = parse("A*02:183")
    assert result.__class__ is Allele, f'Expected parse("A*02:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_184():
    result = parse("A*02:184")
    assert result.__class__ is Allele, f'Expected parse("A*02:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_185():
    result = parse("A*02:185")
    assert result.__class__ is Allele, f'Expected parse("A*02:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_186():
    result = parse("A*02:186")
    assert result.__class__ is Allele, f'Expected parse("A*02:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_187():
    result = parse("A*02:187")
    assert result.__class__ is Allele, f'Expected parse("A*02:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_188():
    result = parse("A*02:188")
    assert result.__class__ is Allele, f'Expected parse("A*02:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_189():
    result = parse("A*02:189")
    assert result.__class__ is Allele, f'Expected parse("A*02:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_19():
    result = parse("A*02:19")
    assert result.__class__ is Allele, f'Expected parse("A*02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_190():
    result = parse("A*02:190")
    assert result.__class__ is Allele, f'Expected parse("A*02:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_191():
    result = parse("A*02:191")
    assert result.__class__ is Allele, f'Expected parse("A*02:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_192():
    result = parse("A*02:192")
    assert result.__class__ is Allele, f'Expected parse("A*02:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_193():
    result = parse("A*02:193")
    assert result.__class__ is Allele, f'Expected parse("A*02:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_194():
    result = parse("A*02:194")
    assert result.__class__ is Allele, f'Expected parse("A*02:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_195():
    result = parse("A*02:195")
    assert result.__class__ is Allele, f'Expected parse("A*02:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_196():
    result = parse("A*02:196")
    assert result.__class__ is Allele, f'Expected parse("A*02:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_197_01():
    result = parse("A*02:197:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:197:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:197:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_197_02():
    result = parse("A*02:197:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:197:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:197:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_198():
    result = parse("A*02:198")
    assert result.__class__ is Allele, f'Expected parse("A*02:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_199():
    result = parse("A*02:199")
    assert result.__class__ is Allele, f'Expected parse("A*02:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_200():
    result = parse("A*02:200")
    assert result.__class__ is Allele, f'Expected parse("A*02:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_201():
    result = parse("A*02:201")
    assert result.__class__ is Allele, f'Expected parse("A*02:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_202():
    result = parse("A*02:202")
    assert result.__class__ is Allele, f'Expected parse("A*02:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_203():
    result = parse("A*02:203")
    assert result.__class__ is Allele, f'Expected parse("A*02:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_204():
    result = parse("A*02:204")
    assert result.__class__ is Allele, f'Expected parse("A*02:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_205():
    result = parse("A*02:205")
    assert result.__class__ is Allele, f'Expected parse("A*02:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_206():
    result = parse("A*02:206")
    assert result.__class__ is Allele, f'Expected parse("A*02:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_207():
    result = parse("A*02:207")
    assert result.__class__ is Allele, f'Expected parse("A*02:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_208():
    result = parse("A*02:208")
    assert result.__class__ is Allele, f'Expected parse("A*02:208") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_209():
    result = parse("A*02:209")
    assert result.__class__ is Allele, f'Expected parse("A*02:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_20_01():
    result = parse("A*02:20:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:20:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:20:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_20_02():
    result = parse("A*02:20:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:20:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:20:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_21():
    result = parse("A*02:21")
    assert result.__class__ is Allele, f'Expected parse("A*02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_210():
    result = parse("A*02:210")
    assert result.__class__ is Allele, f'Expected parse("A*02:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_211_01():
    result = parse("A*02:211:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:211:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:211:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_211_02():
    result = parse("A*02:211:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:211:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:211:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_212():
    result = parse("A*02:212")
    assert result.__class__ is Allele, f'Expected parse("A*02:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_213():
    result = parse("A*02:213")
    assert result.__class__ is Allele, f'Expected parse("A*02:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_214():
    result = parse("A*02:214")
    assert result.__class__ is Allele, f'Expected parse("A*02:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_215():
    result = parse("A*02:215")
    assert result.__class__ is Allele, f'Expected parse("A*02:215") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_216():
    result = parse("A*02:216")
    assert result.__class__ is Allele, f'Expected parse("A*02:216") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_217_01():
    result = parse("A*02:217:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:217:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:217:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_217_02():
    result = parse("A*02:217:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:217:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:217:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_218():
    result = parse("A*02:218")
    assert result.__class__ is Allele, f'Expected parse("A*02:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_219():
    result = parse("A*02:219")
    assert result.__class__ is Allele, f'Expected parse("A*02:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_220():
    result = parse("A*02:220")
    assert result.__class__ is Allele, f'Expected parse("A*02:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_221():
    result = parse("A*02:221")
    assert result.__class__ is Allele, f'Expected parse("A*02:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_222N():
    result = parse("A*02:222N")
    assert result.__class__ is Allele, f'Expected parse("A*02:222N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:222N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_223N():
    result = parse("A*02:223N")
    assert result.__class__ is Allele, f'Expected parse("A*02:223N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:223N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_224():
    result = parse("A*02:224")
    assert result.__class__ is Allele, f'Expected parse("A*02:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_225N():
    result = parse("A*02:225N")
    assert result.__class__ is Allele, f'Expected parse("A*02:225N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:225N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_226N():
    result = parse("A*02:226N")
    assert result.__class__ is Allele, f'Expected parse("A*02:226N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:226N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_227N():
    result = parse("A*02:227N")
    assert result.__class__ is Allele, f'Expected parse("A*02:227N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:227N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_228():
    result = parse("A*02:228")
    assert result.__class__ is Allele, f'Expected parse("A*02:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_229():
    result = parse("A*02:229")
    assert result.__class__ is Allele, f'Expected parse("A*02:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_22_01_01():
    result = parse("A*02:22:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:22:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:22:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_22_01_02():
    result = parse("A*02:22:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:22:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:22:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_22_02():
    result = parse("A*02:22:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:22:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:22:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_230():
    result = parse("A*02:230")
    assert result.__class__ is Allele, f'Expected parse("A*02:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_231():
    result = parse("A*02:231")
    assert result.__class__ is Allele, f'Expected parse("A*02:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_232():
    result = parse("A*02:232")
    assert result.__class__ is Allele, f'Expected parse("A*02:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_233_01():
    result = parse("A*02:233:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:233:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:233:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_233_02():
    result = parse("A*02:233:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:233:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:233:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_234():
    result = parse("A*02:234")
    assert result.__class__ is Allele, f'Expected parse("A*02:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_235():
    result = parse("A*02:235")
    assert result.__class__ is Allele, f'Expected parse("A*02:235") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_236():
    result = parse("A*02:236")
    assert result.__class__ is Allele, f'Expected parse("A*02:236") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_237():
    result = parse("A*02:237")
    assert result.__class__ is Allele, f'Expected parse("A*02:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_238():
    result = parse("A*02:238")
    assert result.__class__ is Allele, f'Expected parse("A*02:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_239():
    result = parse("A*02:239")
    assert result.__class__ is Allele, f'Expected parse("A*02:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_240():
    result = parse("A*02:240")
    assert result.__class__ is Allele, f'Expected parse("A*02:240") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_241():
    result = parse("A*02:241")
    assert result.__class__ is Allele, f'Expected parse("A*02:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_242():
    result = parse("A*02:242")
    assert result.__class__ is Allele, f'Expected parse("A*02:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_243_01():
    result = parse("A*02:243:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:243:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:243:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_243_02():
    result = parse("A*02:243:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:243:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:243:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_243_03():
    result = parse("A*02:243:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:243:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:243:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_244():
    result = parse("A*02:244")
    assert result.__class__ is Allele, f'Expected parse("A*02:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_245():
    result = parse("A*02:245")
    assert result.__class__ is Allele, f'Expected parse("A*02:245") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_246():
    result = parse("A*02:246")
    assert result.__class__ is Allele, f'Expected parse("A*02:246") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_247():
    result = parse("A*02:247")
    assert result.__class__ is Allele, f'Expected parse("A*02:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_248():
    result = parse("A*02:248")
    assert result.__class__ is Allele, f'Expected parse("A*02:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_249():
    result = parse("A*02:249")
    assert result.__class__ is Allele, f'Expected parse("A*02:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_24_01():
    result = parse("A*02:24:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:24:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:24:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_24_02():
    result = parse("A*02:24:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:24:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:24:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_25():
    result = parse("A*02:25")
    assert result.__class__ is Allele, f'Expected parse("A*02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_250N():
    result = parse("A*02:250N")
    assert result.__class__ is Allele, f'Expected parse("A*02:250N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:250N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_251():
    result = parse("A*02:251")
    assert result.__class__ is Allele, f'Expected parse("A*02:251") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_252():
    result = parse("A*02:252")
    assert result.__class__ is Allele, f'Expected parse("A*02:252") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_253():
    result = parse("A*02:253")
    assert result.__class__ is Allele, f'Expected parse("A*02:253") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_254():
    result = parse("A*02:254")
    assert result.__class__ is Allele, f'Expected parse("A*02:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_255():
    result = parse("A*02:255")
    assert result.__class__ is Allele, f'Expected parse("A*02:255") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_256():
    result = parse("A*02:256")
    assert result.__class__ is Allele, f'Expected parse("A*02:256") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_257():
    result = parse("A*02:257")
    assert result.__class__ is Allele, f'Expected parse("A*02:257") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_258():
    result = parse("A*02:258")
    assert result.__class__ is Allele, f'Expected parse("A*02:258") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_259():
    result = parse("A*02:259")
    assert result.__class__ is Allele, f'Expected parse("A*02:259") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_26():
    result = parse("A*02:26")
    assert result.__class__ is Allele, f'Expected parse("A*02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_260():
    result = parse("A*02:260")
    assert result.__class__ is Allele, f'Expected parse("A*02:260") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_261():
    result = parse("A*02:261")
    assert result.__class__ is Allele, f'Expected parse("A*02:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_262():
    result = parse("A*02:262")
    assert result.__class__ is Allele, f'Expected parse("A*02:262") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_263():
    result = parse("A*02:263")
    assert result.__class__ is Allele, f'Expected parse("A*02:263") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_264_01_01():
    result = parse("A*02:264:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:264:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:264:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_264_01_02():
    result = parse("A*02:264:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:264:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:264:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_265():
    result = parse("A*02:265")
    assert result.__class__ is Allele, f'Expected parse("A*02:265") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_266():
    result = parse("A*02:266")
    assert result.__class__ is Allele, f'Expected parse("A*02:266") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_267():
    result = parse("A*02:267")
    assert result.__class__ is Allele, f'Expected parse("A*02:267") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_268():
    result = parse("A*02:268")
    assert result.__class__ is Allele, f'Expected parse("A*02:268") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_269():
    result = parse("A*02:269")
    assert result.__class__ is Allele, f'Expected parse("A*02:269") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_27():
    result = parse("A*02:27")
    assert result.__class__ is Allele, f'Expected parse("A*02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_270():
    result = parse("A*02:270")
    assert result.__class__ is Allele, f'Expected parse("A*02:270") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_271():
    result = parse("A*02:271")
    assert result.__class__ is Allele, f'Expected parse("A*02:271") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_272():
    result = parse("A*02:272")
    assert result.__class__ is Allele, f'Expected parse("A*02:272") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_273():
    result = parse("A*02:273")
    assert result.__class__ is Allele, f'Expected parse("A*02:273") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_274():
    result = parse("A*02:274")
    assert result.__class__ is Allele, f'Expected parse("A*02:274") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_275():
    result = parse("A*02:275")
    assert result.__class__ is Allele, f'Expected parse("A*02:275") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_276():
    result = parse("A*02:276")
    assert result.__class__ is Allele, f'Expected parse("A*02:276") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_277():
    result = parse("A*02:277")
    assert result.__class__ is Allele, f'Expected parse("A*02:277") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_278():
    result = parse("A*02:278")
    assert result.__class__ is Allele, f'Expected parse("A*02:278") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_279():
    result = parse("A*02:279")
    assert result.__class__ is Allele, f'Expected parse("A*02:279") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_28():
    result = parse("A*02:28")
    assert result.__class__ is Allele, f'Expected parse("A*02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_280():
    result = parse("A*02:280")
    assert result.__class__ is Allele, f'Expected parse("A*02:280") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_281():
    result = parse("A*02:281")
    assert result.__class__ is Allele, f'Expected parse("A*02:281") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_282():
    result = parse("A*02:282")
    assert result.__class__ is Allele, f'Expected parse("A*02:282") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_283():
    result = parse("A*02:283")
    assert result.__class__ is Allele, f'Expected parse("A*02:283") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_284N():
    result = parse("A*02:284N")
    assert result.__class__ is Allele, f'Expected parse("A*02:284N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:284N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_285():
    result = parse("A*02:285")
    assert result.__class__ is Allele, f'Expected parse("A*02:285") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_286():
    result = parse("A*02:286")
    assert result.__class__ is Allele, f'Expected parse("A*02:286") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_287():
    result = parse("A*02:287")
    assert result.__class__ is Allele, f'Expected parse("A*02:287") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:287") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_288():
    result = parse("A*02:288")
    assert result.__class__ is Allele, f'Expected parse("A*02:288") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_289_01():
    result = parse("A*02:289:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:289:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:289:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_289_02():
    result = parse("A*02:289:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:289:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:289:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_29():
    result = parse("A*02:29")
    assert result.__class__ is Allele, f'Expected parse("A*02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_290():
    result = parse("A*02:290")
    assert result.__class__ is Allele, f'Expected parse("A*02:290") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_291():
    result = parse("A*02:291")
    assert result.__class__ is Allele, f'Expected parse("A*02:291") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_292():
    result = parse("A*02:292")
    assert result.__class__ is Allele, f'Expected parse("A*02:292") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_293Q():
    result = parse("A*02:293Q")
    assert result.__class__ is Allele, f'Expected parse("A*02:293Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:293Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_294():
    result = parse("A*02:294")
    assert result.__class__ is Allele, f'Expected parse("A*02:294") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_295():
    result = parse("A*02:295")
    assert result.__class__ is Allele, f'Expected parse("A*02:295") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_296():
    result = parse("A*02:296")
    assert result.__class__ is Allele, f'Expected parse("A*02:296") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_297():
    result = parse("A*02:297")
    assert result.__class__ is Allele, f'Expected parse("A*02:297") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_298():
    result = parse("A*02:298")
    assert result.__class__ is Allele, f'Expected parse("A*02:298") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_299():
    result = parse("A*02:299")
    assert result.__class__ is Allele, f'Expected parse("A*02:299") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_300():
    result = parse("A*02:300")
    assert result.__class__ is Allele, f'Expected parse("A*02:300") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_301N():
    result = parse("A*02:301N")
    assert result.__class__ is Allele, f'Expected parse("A*02:301N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:301N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_302():
    result = parse("A*02:302")
    assert result.__class__ is Allele, f'Expected parse("A*02:302") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_303():
    result = parse("A*02:303")
    assert result.__class__ is Allele, f'Expected parse("A*02:303") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:303") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_304():
    result = parse("A*02:304")
    assert result.__class__ is Allele, f'Expected parse("A*02:304") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:304") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_305N():
    result = parse("A*02:305N")
    assert result.__class__ is Allele, f'Expected parse("A*02:305N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:305N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_306():
    result = parse("A*02:306")
    assert result.__class__ is Allele, f'Expected parse("A*02:306") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:306") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_307():
    result = parse("A*02:307")
    assert result.__class__ is Allele, f'Expected parse("A*02:307") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_308():
    result = parse("A*02:308")
    assert result.__class__ is Allele, f'Expected parse("A*02:308") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:308") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_309():
    result = parse("A*02:309")
    assert result.__class__ is Allele, f'Expected parse("A*02:309") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:309") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_30_01():
    result = parse("A*02:30:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:30:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:30:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_30_02():
    result = parse("A*02:30:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:30:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:30:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_31():
    result = parse("A*02:31")
    assert result.__class__ is Allele, f'Expected parse("A*02:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_310():
    result = parse("A*02:310")
    assert result.__class__ is Allele, f'Expected parse("A*02:310") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:310") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_311():
    result = parse("A*02:311")
    assert result.__class__ is Allele, f'Expected parse("A*02:311") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:311") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_312():
    result = parse("A*02:312")
    assert result.__class__ is Allele, f'Expected parse("A*02:312") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:312") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_313():
    result = parse("A*02:313")
    assert result.__class__ is Allele, f'Expected parse("A*02:313") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:313") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_314N():
    result = parse("A*02:314N")
    assert result.__class__ is Allele, f'Expected parse("A*02:314N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:314N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_315():
    result = parse("A*02:315")
    assert result.__class__ is Allele, f'Expected parse("A*02:315") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:315") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_316():
    result = parse("A*02:316")
    assert result.__class__ is Allele, f'Expected parse("A*02:316") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:316") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_317():
    result = parse("A*02:317")
    assert result.__class__ is Allele, f'Expected parse("A*02:317") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:317") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_318():
    result = parse("A*02:318")
    assert result.__class__ is Allele, f'Expected parse("A*02:318") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:318") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_319():
    result = parse("A*02:319")
    assert result.__class__ is Allele, f'Expected parse("A*02:319") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_320():
    result = parse("A*02:320")
    assert result.__class__ is Allele, f'Expected parse("A*02:320") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:320") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_321N():
    result = parse("A*02:321N")
    assert result.__class__ is Allele, f'Expected parse("A*02:321N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:321N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_322():
    result = parse("A*02:322")
    assert result.__class__ is Allele, f'Expected parse("A*02:322") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:322") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_323():
    result = parse("A*02:323")
    assert result.__class__ is Allele, f'Expected parse("A*02:323") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:323") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_324():
    result = parse("A*02:324")
    assert result.__class__ is Allele, f'Expected parse("A*02:324") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:324") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_325():
    result = parse("A*02:325")
    assert result.__class__ is Allele, f'Expected parse("A*02:325") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:325") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_326():
    result = parse("A*02:326")
    assert result.__class__ is Allele, f'Expected parse("A*02:326") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:326") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_327():
    result = parse("A*02:327")
    assert result.__class__ is Allele, f'Expected parse("A*02:327") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:327") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_328():
    result = parse("A*02:328")
    assert result.__class__ is Allele, f'Expected parse("A*02:328") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:328") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_329():
    result = parse("A*02:329")
    assert result.__class__ is Allele, f'Expected parse("A*02:329") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:329") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_32N():
    result = parse("A*02:32N")
    assert result.__class__ is Allele, f'Expected parse("A*02:32N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:32N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_33():
    result = parse("A*02:33")
    assert result.__class__ is Allele, f'Expected parse("A*02:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_330():
    result = parse("A*02:330")
    assert result.__class__ is Allele, f'Expected parse("A*02:330") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:330") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_331():
    result = parse("A*02:331")
    assert result.__class__ is Allele, f'Expected parse("A*02:331") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:331") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_332():
    result = parse("A*02:332")
    assert result.__class__ is Allele, f'Expected parse("A*02:332") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:332") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_333():
    result = parse("A*02:333")
    assert result.__class__ is Allele, f'Expected parse("A*02:333") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:333") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_334():
    result = parse("A*02:334")
    assert result.__class__ is Allele, f'Expected parse("A*02:334") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:334") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_335():
    result = parse("A*02:335")
    assert result.__class__ is Allele, f'Expected parse("A*02:335") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:335") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_336():
    result = parse("A*02:336")
    assert result.__class__ is Allele, f'Expected parse("A*02:336") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:336") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_337():
    result = parse("A*02:337")
    assert result.__class__ is Allele, f'Expected parse("A*02:337") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:337") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_338():
    result = parse("A*02:338")
    assert result.__class__ is Allele, f'Expected parse("A*02:338") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:338") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_339():
    result = parse("A*02:339")
    assert result.__class__ is Allele, f'Expected parse("A*02:339") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:339") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_34():
    result = parse("A*02:34")
    assert result.__class__ is Allele, f'Expected parse("A*02:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_340():
    result = parse("A*02:340")
    assert result.__class__ is Allele, f'Expected parse("A*02:340") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:340") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_341():
    result = parse("A*02:341")
    assert result.__class__ is Allele, f'Expected parse("A*02:341") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:341") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_342():
    result = parse("A*02:342")
    assert result.__class__ is Allele, f'Expected parse("A*02:342") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:342") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_343():
    result = parse("A*02:343")
    assert result.__class__ is Allele, f'Expected parse("A*02:343") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:343") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_344():
    result = parse("A*02:344")
    assert result.__class__ is Allele, f'Expected parse("A*02:344") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:344") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_345():
    result = parse("A*02:345")
    assert result.__class__ is Allele, f'Expected parse("A*02:345") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:345") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_346():
    result = parse("A*02:346")
    assert result.__class__ is Allele, f'Expected parse("A*02:346") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:346") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_347():
    result = parse("A*02:347")
    assert result.__class__ is Allele, f'Expected parse("A*02:347") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:347") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_348():
    result = parse("A*02:348")
    assert result.__class__ is Allele, f'Expected parse("A*02:348") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:348") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_349():
    result = parse("A*02:349")
    assert result.__class__ is Allele, f'Expected parse("A*02:349") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:349") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_350N():
    result = parse("A*02:350N")
    assert result.__class__ is Allele, f'Expected parse("A*02:350N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:350N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_351():
    result = parse("A*02:351")
    assert result.__class__ is Allele, f'Expected parse("A*02:351") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:351") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_352():
    result = parse("A*02:352")
    assert result.__class__ is Allele, f'Expected parse("A*02:352") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:352") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_353():
    result = parse("A*02:353")
    assert result.__class__ is Allele, f'Expected parse("A*02:353") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:353") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_354():
    result = parse("A*02:354")
    assert result.__class__ is Allele, f'Expected parse("A*02:354") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:354") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_355():
    result = parse("A*02:355")
    assert result.__class__ is Allele, f'Expected parse("A*02:355") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:355") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_356N():
    result = parse("A*02:356N")
    assert result.__class__ is Allele, f'Expected parse("A*02:356N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:356N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_357():
    result = parse("A*02:357")
    assert result.__class__ is Allele, f'Expected parse("A*02:357") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:357") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_358():
    result = parse("A*02:358")
    assert result.__class__ is Allele, f'Expected parse("A*02:358") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:358") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_359():
    result = parse("A*02:359")
    assert result.__class__ is Allele, f'Expected parse("A*02:359") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:359") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_35_01():
    result = parse("A*02:35:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:35:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:35:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_35_02():
    result = parse("A*02:35:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:35:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:35:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_35_03():
    result = parse("A*02:35:03")
    assert result.__class__ is Allele, f'Expected parse("A*02:35:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:35:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_36():
    result = parse("A*02:36")
    assert result.__class__ is Allele, f'Expected parse("A*02:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_360():
    result = parse("A*02:360")
    assert result.__class__ is Allele, f'Expected parse("A*02:360") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:360") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_361():
    result = parse("A*02:361")
    assert result.__class__ is Allele, f'Expected parse("A*02:361") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:361") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_362():
    result = parse("A*02:362")
    assert result.__class__ is Allele, f'Expected parse("A*02:362") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:362") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_363():
    result = parse("A*02:363")
    assert result.__class__ is Allele, f'Expected parse("A*02:363") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:363") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_364():
    result = parse("A*02:364")
    assert result.__class__ is Allele, f'Expected parse("A*02:364") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:364") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_365():
    result = parse("A*02:365")
    assert result.__class__ is Allele, f'Expected parse("A*02:365") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:365") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_366N():
    result = parse("A*02:366N")
    assert result.__class__ is Allele, f'Expected parse("A*02:366N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:366N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_367():
    result = parse("A*02:367")
    assert result.__class__ is Allele, f'Expected parse("A*02:367") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:367") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_368():
    result = parse("A*02:368")
    assert result.__class__ is Allele, f'Expected parse("A*02:368") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:368") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_369():
    result = parse("A*02:369")
    assert result.__class__ is Allele, f'Expected parse("A*02:369") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:369") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_37():
    result = parse("A*02:37")
    assert result.__class__ is Allele, f'Expected parse("A*02:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_370():
    result = parse("A*02:370")
    assert result.__class__ is Allele, f'Expected parse("A*02:370") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:370") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_371():
    result = parse("A*02:371")
    assert result.__class__ is Allele, f'Expected parse("A*02:371") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:371") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_372():
    result = parse("A*02:372")
    assert result.__class__ is Allele, f'Expected parse("A*02:372") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:372") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_373N():
    result = parse("A*02:373N")
    assert result.__class__ is Allele, f'Expected parse("A*02:373N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:373N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_374():
    result = parse("A*02:374")
    assert result.__class__ is Allele, f'Expected parse("A*02:374") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:374") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_375():
    result = parse("A*02:375")
    assert result.__class__ is Allele, f'Expected parse("A*02:375") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:375") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_376():
    result = parse("A*02:376")
    assert result.__class__ is Allele, f'Expected parse("A*02:376") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:376") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_377():
    result = parse("A*02:377")
    assert result.__class__ is Allele, f'Expected parse("A*02:377") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:377") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_378():
    result = parse("A*02:378")
    assert result.__class__ is Allele, f'Expected parse("A*02:378") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:378") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_379():
    result = parse("A*02:379")
    assert result.__class__ is Allele, f'Expected parse("A*02:379") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:379") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_38():
    result = parse("A*02:38")
    assert result.__class__ is Allele, f'Expected parse("A*02:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_380():
    result = parse("A*02:380")
    assert result.__class__ is Allele, f'Expected parse("A*02:380") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:380") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_381():
    result = parse("A*02:381")
    assert result.__class__ is Allele, f'Expected parse("A*02:381") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:381") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_382():
    result = parse("A*02:382")
    assert result.__class__ is Allele, f'Expected parse("A*02:382") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:382") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_383():
    result = parse("A*02:383")
    assert result.__class__ is Allele, f'Expected parse("A*02:383") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:383") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_384():
    result = parse("A*02:384")
    assert result.__class__ is Allele, f'Expected parse("A*02:384") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:384") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_385():
    result = parse("A*02:385")
    assert result.__class__ is Allele, f'Expected parse("A*02:385") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:385") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_386():
    result = parse("A*02:386")
    assert result.__class__ is Allele, f'Expected parse("A*02:386") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:386") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_387():
    result = parse("A*02:387")
    assert result.__class__ is Allele, f'Expected parse("A*02:387") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:387") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_388():
    result = parse("A*02:388")
    assert result.__class__ is Allele, f'Expected parse("A*02:388") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:388") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_389():
    result = parse("A*02:389")
    assert result.__class__ is Allele, f'Expected parse("A*02:389") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:389") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_39():
    result = parse("A*02:39")
    assert result.__class__ is Allele, f'Expected parse("A*02:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_390():
    result = parse("A*02:390")
    assert result.__class__ is Allele, f'Expected parse("A*02:390") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:390") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_391():
    result = parse("A*02:391")
    assert result.__class__ is Allele, f'Expected parse("A*02:391") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:391") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_392():
    result = parse("A*02:392")
    assert result.__class__ is Allele, f'Expected parse("A*02:392") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:392") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_393():
    result = parse("A*02:393")
    assert result.__class__ is Allele, f'Expected parse("A*02:393") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:393") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_394():
    result = parse("A*02:394")
    assert result.__class__ is Allele, f'Expected parse("A*02:394") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:394") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_395N():
    result = parse("A*02:395N")
    assert result.__class__ is Allele, f'Expected parse("A*02:395N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:395N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_396():
    result = parse("A*02:396")
    assert result.__class__ is Allele, f'Expected parse("A*02:396") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:396") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_397():
    result = parse("A*02:397")
    assert result.__class__ is Allele, f'Expected parse("A*02:397") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:397") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_398():
    result = parse("A*02:398")
    assert result.__class__ is Allele, f'Expected parse("A*02:398") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:398") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_399():
    result = parse("A*02:399")
    assert result.__class__ is Allele, f'Expected parse("A*02:399") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:399") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_400():
    result = parse("A*02:400")
    assert result.__class__ is Allele, f'Expected parse("A*02:400") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:400") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_401():
    result = parse("A*02:401")
    assert result.__class__ is Allele, f'Expected parse("A*02:401") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:401") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_402():
    result = parse("A*02:402")
    assert result.__class__ is Allele, f'Expected parse("A*02:402") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:402") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_403():
    result = parse("A*02:403")
    assert result.__class__ is Allele, f'Expected parse("A*02:403") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:403") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_404():
    result = parse("A*02:404")
    assert result.__class__ is Allele, f'Expected parse("A*02:404") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:404") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_405():
    result = parse("A*02:405")
    assert result.__class__ is Allele, f'Expected parse("A*02:405") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:405") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_406():
    result = parse("A*02:406")
    assert result.__class__ is Allele, f'Expected parse("A*02:406") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:406") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_407():
    result = parse("A*02:407")
    assert result.__class__ is Allele, f'Expected parse("A*02:407") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:407") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_408():
    result = parse("A*02:408")
    assert result.__class__ is Allele, f'Expected parse("A*02:408") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:408") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_409():
    result = parse("A*02:409")
    assert result.__class__ is Allele, f'Expected parse("A*02:409") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:409") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_40_01():
    result = parse("A*02:40:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:40:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:40:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_40_02():
    result = parse("A*02:40:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:40:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:40:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_41():
    result = parse("A*02:41")
    assert result.__class__ is Allele, f'Expected parse("A*02:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_410():
    result = parse("A*02:410")
    assert result.__class__ is Allele, f'Expected parse("A*02:410") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:410") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_411():
    result = parse("A*02:411")
    assert result.__class__ is Allele, f'Expected parse("A*02:411") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:411") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_412():
    result = parse("A*02:412")
    assert result.__class__ is Allele, f'Expected parse("A*02:412") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:412") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_413():
    result = parse("A*02:413")
    assert result.__class__ is Allele, f'Expected parse("A*02:413") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:413") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_414():
    result = parse("A*02:414")
    assert result.__class__ is Allele, f'Expected parse("A*02:414") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:414") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_415():
    result = parse("A*02:415")
    assert result.__class__ is Allele, f'Expected parse("A*02:415") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:415") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_416():
    result = parse("A*02:416")
    assert result.__class__ is Allele, f'Expected parse("A*02:416") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:416") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_417():
    result = parse("A*02:417")
    assert result.__class__ is Allele, f'Expected parse("A*02:417") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:417") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_418():
    result = parse("A*02:418")
    assert result.__class__ is Allele, f'Expected parse("A*02:418") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:418") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_419_01():
    result = parse("A*02:419:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:419:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:419:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_419_02():
    result = parse("A*02:419:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:419:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:419:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_420():
    result = parse("A*02:420")
    assert result.__class__ is Allele, f'Expected parse("A*02:420") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:420") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_421():
    result = parse("A*02:421")
    assert result.__class__ is Allele, f'Expected parse("A*02:421") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:421") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_422():
    result = parse("A*02:422")
    assert result.__class__ is Allele, f'Expected parse("A*02:422") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:422") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_423():
    result = parse("A*02:423")
    assert result.__class__ is Allele, f'Expected parse("A*02:423") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:423") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_424():
    result = parse("A*02:424")
    assert result.__class__ is Allele, f'Expected parse("A*02:424") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:424") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_425():
    result = parse("A*02:425")
    assert result.__class__ is Allele, f'Expected parse("A*02:425") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:425") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_426():
    result = parse("A*02:426")
    assert result.__class__ is Allele, f'Expected parse("A*02:426") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:426") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_427():
    result = parse("A*02:427")
    assert result.__class__ is Allele, f'Expected parse("A*02:427") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:427") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_428():
    result = parse("A*02:428")
    assert result.__class__ is Allele, f'Expected parse("A*02:428") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:428") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_429():
    result = parse("A*02:429")
    assert result.__class__ is Allele, f'Expected parse("A*02:429") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:429") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_42_01():
    result = parse("A*02:42:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:42:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:42:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_42_02():
    result = parse("A*02:42:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:42:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:42:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_430():
    result = parse("A*02:430")
    assert result.__class__ is Allele, f'Expected parse("A*02:430") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:430") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_431():
    result = parse("A*02:431")
    assert result.__class__ is Allele, f'Expected parse("A*02:431") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:431") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_432():
    result = parse("A*02:432")
    assert result.__class__ is Allele, f'Expected parse("A*02:432") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:432") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_433():
    result = parse("A*02:433")
    assert result.__class__ is Allele, f'Expected parse("A*02:433") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:433") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_434():
    result = parse("A*02:434")
    assert result.__class__ is Allele, f'Expected parse("A*02:434") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:434") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_435():
    result = parse("A*02:435")
    assert result.__class__ is Allele, f'Expected parse("A*02:435") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:435") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_436():
    result = parse("A*02:436")
    assert result.__class__ is Allele, f'Expected parse("A*02:436") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:436") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_437Q():
    result = parse("A*02:437Q")
    assert result.__class__ is Allele, f'Expected parse("A*02:437Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:437Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_438():
    result = parse("A*02:438")
    assert result.__class__ is Allele, f'Expected parse("A*02:438") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:438") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_439N():
    result = parse("A*02:439N")
    assert result.__class__ is Allele, f'Expected parse("A*02:439N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:439N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_43N():
    result = parse("A*02:43N")
    assert result.__class__ is Allele, f'Expected parse("A*02:43N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:43N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_44():
    result = parse("A*02:44")
    assert result.__class__ is Allele, f'Expected parse("A*02:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_440Q():
    result = parse("A*02:440Q")
    assert result.__class__ is Allele, f'Expected parse("A*02:440Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:440Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_441():
    result = parse("A*02:441")
    assert result.__class__ is Allele, f'Expected parse("A*02:441") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:441") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_442():
    result = parse("A*02:442")
    assert result.__class__ is Allele, f'Expected parse("A*02:442") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:442") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_443():
    result = parse("A*02:443")
    assert result.__class__ is Allele, f'Expected parse("A*02:443") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:443") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_444():
    result = parse("A*02:444")
    assert result.__class__ is Allele, f'Expected parse("A*02:444") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:444") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_445():
    result = parse("A*02:445")
    assert result.__class__ is Allele, f'Expected parse("A*02:445") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:445") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_446():
    result = parse("A*02:446")
    assert result.__class__ is Allele, f'Expected parse("A*02:446") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:446") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_447():
    result = parse("A*02:447")
    assert result.__class__ is Allele, f'Expected parse("A*02:447") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:447") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_448():
    result = parse("A*02:448")
    assert result.__class__ is Allele, f'Expected parse("A*02:448") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:448") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_449():
    result = parse("A*02:449")
    assert result.__class__ is Allele, f'Expected parse("A*02:449") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:449") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_45():
    result = parse("A*02:45")
    assert result.__class__ is Allele, f'Expected parse("A*02:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_450():
    result = parse("A*02:450")
    assert result.__class__ is Allele, f'Expected parse("A*02:450") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:450") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_451():
    result = parse("A*02:451")
    assert result.__class__ is Allele, f'Expected parse("A*02:451") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:451") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_452():
    result = parse("A*02:452")
    assert result.__class__ is Allele, f'Expected parse("A*02:452") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:452") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_453():
    result = parse("A*02:453")
    assert result.__class__ is Allele, f'Expected parse("A*02:453") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:453") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_454():
    result = parse("A*02:454")
    assert result.__class__ is Allele, f'Expected parse("A*02:454") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:454") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_455():
    result = parse("A*02:455")
    assert result.__class__ is Allele, f'Expected parse("A*02:455") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:455") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_456():
    result = parse("A*02:456")
    assert result.__class__ is Allele, f'Expected parse("A*02:456") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:456") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_457():
    result = parse("A*02:457")
    assert result.__class__ is Allele, f'Expected parse("A*02:457") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:457") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_458():
    result = parse("A*02:458")
    assert result.__class__ is Allele, f'Expected parse("A*02:458") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:458") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_459():
    result = parse("A*02:459")
    assert result.__class__ is Allele, f'Expected parse("A*02:459") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:459") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_46():
    result = parse("A*02:46")
    assert result.__class__ is Allele, f'Expected parse("A*02:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_460():
    result = parse("A*02:460")
    assert result.__class__ is Allele, f'Expected parse("A*02:460") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:460") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_461():
    result = parse("A*02:461")
    assert result.__class__ is Allele, f'Expected parse("A*02:461") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:461") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_462():
    result = parse("A*02:462")
    assert result.__class__ is Allele, f'Expected parse("A*02:462") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:462") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_463():
    result = parse("A*02:463")
    assert result.__class__ is Allele, f'Expected parse("A*02:463") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:463") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_464():
    result = parse("A*02:464")
    assert result.__class__ is Allele, f'Expected parse("A*02:464") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:464") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_465():
    result = parse("A*02:465")
    assert result.__class__ is Allele, f'Expected parse("A*02:465") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:465") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_466():
    result = parse("A*02:466")
    assert result.__class__ is Allele, f'Expected parse("A*02:466") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:466") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_467():
    result = parse("A*02:467")
    assert result.__class__ is Allele, f'Expected parse("A*02:467") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:467") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_468_01N():
    result = parse("A*02:468:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:468:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:468:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_468_02N():
    result = parse("A*02:468:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:468:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:468:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_469():
    result = parse("A*02:469")
    assert result.__class__ is Allele, f'Expected parse("A*02:469") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:469") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_47():
    result = parse("A*02:47")
    assert result.__class__ is Allele, f'Expected parse("A*02:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_470():
    result = parse("A*02:470")
    assert result.__class__ is Allele, f'Expected parse("A*02:470") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:470") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_471():
    result = parse("A*02:471")
    assert result.__class__ is Allele, f'Expected parse("A*02:471") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:471") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_472():
    result = parse("A*02:472")
    assert result.__class__ is Allele, f'Expected parse("A*02:472") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:472") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_473():
    result = parse("A*02:473")
    assert result.__class__ is Allele, f'Expected parse("A*02:473") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:473") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_474():
    result = parse("A*02:474")
    assert result.__class__ is Allele, f'Expected parse("A*02:474") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:474") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_475():
    result = parse("A*02:475")
    assert result.__class__ is Allele, f'Expected parse("A*02:475") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:475") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_476N():
    result = parse("A*02:476N")
    assert result.__class__ is Allele, f'Expected parse("A*02:476N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:476N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_477():
    result = parse("A*02:477")
    assert result.__class__ is Allele, f'Expected parse("A*02:477") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:477") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_478():
    result = parse("A*02:478")
    assert result.__class__ is Allele, f'Expected parse("A*02:478") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:478") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_479():
    result = parse("A*02:479")
    assert result.__class__ is Allele, f'Expected parse("A*02:479") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:479") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_48():
    result = parse("A*02:48")
    assert result.__class__ is Allele, f'Expected parse("A*02:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_480():
    result = parse("A*02:480")
    assert result.__class__ is Allele, f'Expected parse("A*02:480") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:480") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_481():
    result = parse("A*02:481")
    assert result.__class__ is Allele, f'Expected parse("A*02:481") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:481") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_482():
    result = parse("A*02:482")
    assert result.__class__ is Allele, f'Expected parse("A*02:482") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:482") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_483():
    result = parse("A*02:483")
    assert result.__class__ is Allele, f'Expected parse("A*02:483") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:483") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_484():
    result = parse("A*02:484")
    assert result.__class__ is Allele, f'Expected parse("A*02:484") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:484") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_485():
    result = parse("A*02:485")
    assert result.__class__ is Allele, f'Expected parse("A*02:485") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:485") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_486():
    result = parse("A*02:486")
    assert result.__class__ is Allele, f'Expected parse("A*02:486") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:486") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_487():
    result = parse("A*02:487")
    assert result.__class__ is Allele, f'Expected parse("A*02:487") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:487") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_488():
    result = parse("A*02:488")
    assert result.__class__ is Allele, f'Expected parse("A*02:488") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:488") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_489():
    result = parse("A*02:489")
    assert result.__class__ is Allele, f'Expected parse("A*02:489") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:489") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_490N():
    result = parse("A*02:490N")
    assert result.__class__ is Allele, f'Expected parse("A*02:490N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:490N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_491():
    result = parse("A*02:491")
    assert result.__class__ is Allele, f'Expected parse("A*02:491") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:491") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_492():
    result = parse("A*02:492")
    assert result.__class__ is Allele, f'Expected parse("A*02:492") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:492") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_493():
    result = parse("A*02:493")
    assert result.__class__ is Allele, f'Expected parse("A*02:493") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:493") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_494():
    result = parse("A*02:494")
    assert result.__class__ is Allele, f'Expected parse("A*02:494") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:494") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_495():
    result = parse("A*02:495")
    assert result.__class__ is Allele, f'Expected parse("A*02:495") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:495") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_496():
    result = parse("A*02:496")
    assert result.__class__ is Allele, f'Expected parse("A*02:496") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:496") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_497():
    result = parse("A*02:497")
    assert result.__class__ is Allele, f'Expected parse("A*02:497") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:497") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_498():
    result = parse("A*02:498")
    assert result.__class__ is Allele, f'Expected parse("A*02:498") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:498") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_499():
    result = parse("A*02:499")
    assert result.__class__ is Allele, f'Expected parse("A*02:499") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:499") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_49_01():
    result = parse("A*02:49:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:49:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:49:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_49_02():
    result = parse("A*02:49:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:49:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:49:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_50():
    result = parse("A*02:50")
    assert result.__class__ is Allele, f'Expected parse("A*02:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_500Q():
    result = parse("A*02:500Q")
    assert result.__class__ is Allele, f'Expected parse("A*02:500Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:500Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_501N():
    result = parse("A*02:501N")
    assert result.__class__ is Allele, f'Expected parse("A*02:501N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:501N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_502():
    result = parse("A*02:502")
    assert result.__class__ is Allele, f'Expected parse("A*02:502") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:502") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_503():
    result = parse("A*02:503")
    assert result.__class__ is Allele, f'Expected parse("A*02:503") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:503") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_504():
    result = parse("A*02:504")
    assert result.__class__ is Allele, f'Expected parse("A*02:504") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:504") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_505():
    result = parse("A*02:505")
    assert result.__class__ is Allele, f'Expected parse("A*02:505") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:505") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_506N():
    result = parse("A*02:506N")
    assert result.__class__ is Allele, f'Expected parse("A*02:506N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:506N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_507():
    result = parse("A*02:507")
    assert result.__class__ is Allele, f'Expected parse("A*02:507") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:507") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_508():
    result = parse("A*02:508")
    assert result.__class__ is Allele, f'Expected parse("A*02:508") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:508") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_509():
    result = parse("A*02:509")
    assert result.__class__ is Allele, f'Expected parse("A*02:509") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:509") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_51():
    result = parse("A*02:51")
    assert result.__class__ is Allele, f'Expected parse("A*02:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_510():
    result = parse("A*02:510")
    assert result.__class__ is Allele, f'Expected parse("A*02:510") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:510") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_511():
    result = parse("A*02:511")
    assert result.__class__ is Allele, f'Expected parse("A*02:511") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:511") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_512():
    result = parse("A*02:512")
    assert result.__class__ is Allele, f'Expected parse("A*02:512") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:512") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_513():
    result = parse("A*02:513")
    assert result.__class__ is Allele, f'Expected parse("A*02:513") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:513") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_514N():
    result = parse("A*02:514N")
    assert result.__class__ is Allele, f'Expected parse("A*02:514N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:514N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_515():
    result = parse("A*02:515")
    assert result.__class__ is Allele, f'Expected parse("A*02:515") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:515") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_516N():
    result = parse("A*02:516N")
    assert result.__class__ is Allele, f'Expected parse("A*02:516N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:516N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_517():
    result = parse("A*02:517")
    assert result.__class__ is Allele, f'Expected parse("A*02:517") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:517") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_518():
    result = parse("A*02:518")
    assert result.__class__ is Allele, f'Expected parse("A*02:518") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:518") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_519():
    result = parse("A*02:519")
    assert result.__class__ is Allele, f'Expected parse("A*02:519") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:519") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_52():
    result = parse("A*02:52")
    assert result.__class__ is Allele, f'Expected parse("A*02:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_520():
    result = parse("A*02:520")
    assert result.__class__ is Allele, f'Expected parse("A*02:520") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:520") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_521():
    result = parse("A*02:521")
    assert result.__class__ is Allele, f'Expected parse("A*02:521") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:521") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_522():
    result = parse("A*02:522")
    assert result.__class__ is Allele, f'Expected parse("A*02:522") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:522") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_523():
    result = parse("A*02:523")
    assert result.__class__ is Allele, f'Expected parse("A*02:523") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:523") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_524_01():
    result = parse("A*02:524:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:524:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:524:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_524_02():
    result = parse("A*02:524:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:524:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:524:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_525N():
    result = parse("A*02:525N")
    assert result.__class__ is Allele, f'Expected parse("A*02:525N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:525N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_526():
    result = parse("A*02:526")
    assert result.__class__ is Allele, f'Expected parse("A*02:526") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:526") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_527():
    result = parse("A*02:527")
    assert result.__class__ is Allele, f'Expected parse("A*02:527") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:527") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_528_01():
    result = parse("A*02:528:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:528:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:528:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_528_02():
    result = parse("A*02:528:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:528:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:528:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_529():
    result = parse("A*02:529")
    assert result.__class__ is Allele, f'Expected parse("A*02:529") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:529") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_530():
    result = parse("A*02:530")
    assert result.__class__ is Allele, f'Expected parse("A*02:530") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:530") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_531():
    result = parse("A*02:531")
    assert result.__class__ is Allele, f'Expected parse("A*02:531") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:531") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_532():
    result = parse("A*02:532")
    assert result.__class__ is Allele, f'Expected parse("A*02:532") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:532") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_533():
    result = parse("A*02:533")
    assert result.__class__ is Allele, f'Expected parse("A*02:533") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:533") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_534():
    result = parse("A*02:534")
    assert result.__class__ is Allele, f'Expected parse("A*02:534") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:534") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_535():
    result = parse("A*02:535")
    assert result.__class__ is Allele, f'Expected parse("A*02:535") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:535") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_536():
    result = parse("A*02:536")
    assert result.__class__ is Allele, f'Expected parse("A*02:536") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:536") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_537():
    result = parse("A*02:537")
    assert result.__class__ is Allele, f'Expected parse("A*02:537") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:537") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_538():
    result = parse("A*02:538")
    assert result.__class__ is Allele, f'Expected parse("A*02:538") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:538") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_539():
    result = parse("A*02:539")
    assert result.__class__ is Allele, f'Expected parse("A*02:539") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:539") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_53N():
    result = parse("A*02:53N")
    assert result.__class__ is Allele, f'Expected parse("A*02:53N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:53N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_54():
    result = parse("A*02:54")
    assert result.__class__ is Allele, f'Expected parse("A*02:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_540N():
    result = parse("A*02:540N")
    assert result.__class__ is Allele, f'Expected parse("A*02:540N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:540N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_541():
    result = parse("A*02:541")
    assert result.__class__ is Allele, f'Expected parse("A*02:541") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:541") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_542():
    result = parse("A*02:542")
    assert result.__class__ is Allele, f'Expected parse("A*02:542") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:542") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_543():
    result = parse("A*02:543")
    assert result.__class__ is Allele, f'Expected parse("A*02:543") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:543") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_544():
    result = parse("A*02:544")
    assert result.__class__ is Allele, f'Expected parse("A*02:544") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:544") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_545():
    result = parse("A*02:545")
    assert result.__class__ is Allele, f'Expected parse("A*02:545") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:545") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_546():
    result = parse("A*02:546")
    assert result.__class__ is Allele, f'Expected parse("A*02:546") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:546") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_547():
    result = parse("A*02:547")
    assert result.__class__ is Allele, f'Expected parse("A*02:547") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:547") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_548():
    result = parse("A*02:548")
    assert result.__class__ is Allele, f'Expected parse("A*02:548") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:548") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_549():
    result = parse("A*02:549")
    assert result.__class__ is Allele, f'Expected parse("A*02:549") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:549") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_55():
    result = parse("A*02:55")
    assert result.__class__ is Allele, f'Expected parse("A*02:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_550():
    result = parse("A*02:550")
    assert result.__class__ is Allele, f'Expected parse("A*02:550") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:550") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_551():
    result = parse("A*02:551")
    assert result.__class__ is Allele, f'Expected parse("A*02:551") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:551") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_552():
    result = parse("A*02:552")
    assert result.__class__ is Allele, f'Expected parse("A*02:552") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:552") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_553():
    result = parse("A*02:553")
    assert result.__class__ is Allele, f'Expected parse("A*02:553") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:553") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_554():
    result = parse("A*02:554")
    assert result.__class__ is Allele, f'Expected parse("A*02:554") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:554") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_555():
    result = parse("A*02:555")
    assert result.__class__ is Allele, f'Expected parse("A*02:555") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:555") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_556():
    result = parse("A*02:556")
    assert result.__class__ is Allele, f'Expected parse("A*02:556") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:556") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_557():
    result = parse("A*02:557")
    assert result.__class__ is Allele, f'Expected parse("A*02:557") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:557") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_558():
    result = parse("A*02:558")
    assert result.__class__ is Allele, f'Expected parse("A*02:558") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:558") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_559():
    result = parse("A*02:559")
    assert result.__class__ is Allele, f'Expected parse("A*02:559") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:559") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_560():
    result = parse("A*02:560")
    assert result.__class__ is Allele, f'Expected parse("A*02:560") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:560") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_561():
    result = parse("A*02:561")
    assert result.__class__ is Allele, f'Expected parse("A*02:561") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:561") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_562():
    result = parse("A*02:562")
    assert result.__class__ is Allele, f'Expected parse("A*02:562") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:562") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_563():
    result = parse("A*02:563")
    assert result.__class__ is Allele, f'Expected parse("A*02:563") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:563") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_564():
    result = parse("A*02:564")
    assert result.__class__ is Allele, f'Expected parse("A*02:564") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:564") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_565():
    result = parse("A*02:565")
    assert result.__class__ is Allele, f'Expected parse("A*02:565") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:565") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_566():
    result = parse("A*02:566")
    assert result.__class__ is Allele, f'Expected parse("A*02:566") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:566") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_567():
    result = parse("A*02:567")
    assert result.__class__ is Allele, f'Expected parse("A*02:567") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:567") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_568():
    result = parse("A*02:568")
    assert result.__class__ is Allele, f'Expected parse("A*02:568") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:568") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_569():
    result = parse("A*02:569")
    assert result.__class__ is Allele, f'Expected parse("A*02:569") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:569") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_56_01():
    result = parse("A*02:56:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:56:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:56:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_56_02():
    result = parse("A*02:56:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:56:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:56:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_57():
    result = parse("A*02:57")
    assert result.__class__ is Allele, f'Expected parse("A*02:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_570_01():
    result = parse("A*02:570:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:570:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:570:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_570_02():
    result = parse("A*02:570:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:570:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:570:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_571():
    result = parse("A*02:571")
    assert result.__class__ is Allele, f'Expected parse("A*02:571") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:571") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_572():
    result = parse("A*02:572")
    assert result.__class__ is Allele, f'Expected parse("A*02:572") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:572") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_573():
    result = parse("A*02:573")
    assert result.__class__ is Allele, f'Expected parse("A*02:573") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:573") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_574():
    result = parse("A*02:574")
    assert result.__class__ is Allele, f'Expected parse("A*02:574") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:574") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_575():
    result = parse("A*02:575")
    assert result.__class__ is Allele, f'Expected parse("A*02:575") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:575") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_576():
    result = parse("A*02:576")
    assert result.__class__ is Allele, f'Expected parse("A*02:576") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:576") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_577():
    result = parse("A*02:577")
    assert result.__class__ is Allele, f'Expected parse("A*02:577") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:577") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_578():
    result = parse("A*02:578")
    assert result.__class__ is Allele, f'Expected parse("A*02:578") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:578") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_579():
    result = parse("A*02:579")
    assert result.__class__ is Allele, f'Expected parse("A*02:579") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:579") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_58():
    result = parse("A*02:58")
    assert result.__class__ is Allele, f'Expected parse("A*02:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_580():
    result = parse("A*02:580")
    assert result.__class__ is Allele, f'Expected parse("A*02:580") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:580") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_581Q():
    result = parse("A*02:581Q")
    assert result.__class__ is Allele, f'Expected parse("A*02:581Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:581Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_582():
    result = parse("A*02:582")
    assert result.__class__ is Allele, f'Expected parse("A*02:582") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:582") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_583():
    result = parse("A*02:583")
    assert result.__class__ is Allele, f'Expected parse("A*02:583") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:583") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_584():
    result = parse("A*02:584")
    assert result.__class__ is Allele, f'Expected parse("A*02:584") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:584") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_585():
    result = parse("A*02:585")
    assert result.__class__ is Allele, f'Expected parse("A*02:585") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:585") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_586():
    result = parse("A*02:586")
    assert result.__class__ is Allele, f'Expected parse("A*02:586") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:586") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_587():
    result = parse("A*02:587")
    assert result.__class__ is Allele, f'Expected parse("A*02:587") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:587") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_588():
    result = parse("A*02:588")
    assert result.__class__ is Allele, f'Expected parse("A*02:588") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:588") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_589():
    result = parse("A*02:589")
    assert result.__class__ is Allele, f'Expected parse("A*02:589") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:589") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_59():
    result = parse("A*02:59")
    assert result.__class__ is Allele, f'Expected parse("A*02:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_590():
    result = parse("A*02:590")
    assert result.__class__ is Allele, f'Expected parse("A*02:590") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:590") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_591_01():
    result = parse("A*02:591:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:591:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:591:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_591_02():
    result = parse("A*02:591:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:591:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:591:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_592():
    result = parse("A*02:592")
    assert result.__class__ is Allele, f'Expected parse("A*02:592") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:592") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_593():
    result = parse("A*02:593")
    assert result.__class__ is Allele, f'Expected parse("A*02:593") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:593") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_594():
    result = parse("A*02:594")
    assert result.__class__ is Allele, f'Expected parse("A*02:594") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:594") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_595():
    result = parse("A*02:595")
    assert result.__class__ is Allele, f'Expected parse("A*02:595") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:595") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_596():
    result = parse("A*02:596")
    assert result.__class__ is Allele, f'Expected parse("A*02:596") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:596") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_597():
    result = parse("A*02:597")
    assert result.__class__ is Allele, f'Expected parse("A*02:597") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:597") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_598():
    result = parse("A*02:598")
    assert result.__class__ is Allele, f'Expected parse("A*02:598") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:598") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_599():
    result = parse("A*02:599")
    assert result.__class__ is Allele, f'Expected parse("A*02:599") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:599") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_600():
    result = parse("A*02:600")
    assert result.__class__ is Allele, f'Expected parse("A*02:600") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:600") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_601():
    result = parse("A*02:601")
    assert result.__class__ is Allele, f'Expected parse("A*02:601") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:601") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_602():
    result = parse("A*02:602")
    assert result.__class__ is Allele, f'Expected parse("A*02:602") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:602") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_603():
    result = parse("A*02:603")
    assert result.__class__ is Allele, f'Expected parse("A*02:603") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:603") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_604():
    result = parse("A*02:604")
    assert result.__class__ is Allele, f'Expected parse("A*02:604") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:604") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_605Q():
    result = parse("A*02:605Q")
    assert result.__class__ is Allele, f'Expected parse("A*02:605Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:605Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_606():
    result = parse("A*02:606")
    assert result.__class__ is Allele, f'Expected parse("A*02:606") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:606") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_607():
    result = parse("A*02:607")
    assert result.__class__ is Allele, f'Expected parse("A*02:607") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:607") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_608N():
    result = parse("A*02:608N")
    assert result.__class__ is Allele, f'Expected parse("A*02:608N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:608N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_609():
    result = parse("A*02:609")
    assert result.__class__ is Allele, f'Expected parse("A*02:609") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:609") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_60_01():
    result = parse("A*02:60:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:60:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:60:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_60_02():
    result = parse("A*02:60:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:60:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:60:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_61():
    result = parse("A*02:61")
    assert result.__class__ is Allele, f'Expected parse("A*02:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_610_01():
    result = parse("A*02:610:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:610:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:610:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_610_02():
    result = parse("A*02:610:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:610:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:610:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_611():
    result = parse("A*02:611")
    assert result.__class__ is Allele, f'Expected parse("A*02:611") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:611") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_612():
    result = parse("A*02:612")
    assert result.__class__ is Allele, f'Expected parse("A*02:612") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:612") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_613():
    result = parse("A*02:613")
    assert result.__class__ is Allele, f'Expected parse("A*02:613") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:613") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_614():
    result = parse("A*02:614")
    assert result.__class__ is Allele, f'Expected parse("A*02:614") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:614") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_615():
    result = parse("A*02:615")
    assert result.__class__ is Allele, f'Expected parse("A*02:615") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:615") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_616():
    result = parse("A*02:616")
    assert result.__class__ is Allele, f'Expected parse("A*02:616") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:616") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_617():
    result = parse("A*02:617")
    assert result.__class__ is Allele, f'Expected parse("A*02:617") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:617") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_618Q():
    result = parse("A*02:618Q")
    assert result.__class__ is Allele, f'Expected parse("A*02:618Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:618Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_619_01():
    result = parse("A*02:619:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:619:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:619:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_619_02():
    result = parse("A*02:619:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:619:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:619:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_62():
    result = parse("A*02:62")
    assert result.__class__ is Allele, f'Expected parse("A*02:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_620():
    result = parse("A*02:620")
    assert result.__class__ is Allele, f'Expected parse("A*02:620") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:620") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_621():
    result = parse("A*02:621")
    assert result.__class__ is Allele, f'Expected parse("A*02:621") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:621") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_622N():
    result = parse("A*02:622N")
    assert result.__class__ is Allele, f'Expected parse("A*02:622N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:622N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_623():
    result = parse("A*02:623")
    assert result.__class__ is Allele, f'Expected parse("A*02:623") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:623") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_624():
    result = parse("A*02:624")
    assert result.__class__ is Allele, f'Expected parse("A*02:624") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:624") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_625():
    result = parse("A*02:625")
    assert result.__class__ is Allele, f'Expected parse("A*02:625") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:625") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_626():
    result = parse("A*02:626")
    assert result.__class__ is Allele, f'Expected parse("A*02:626") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:626") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_627():
    result = parse("A*02:627")
    assert result.__class__ is Allele, f'Expected parse("A*02:627") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:627") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_628():
    result = parse("A*02:628")
    assert result.__class__ is Allele, f'Expected parse("A*02:628") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:628") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_629():
    result = parse("A*02:629")
    assert result.__class__ is Allele, f'Expected parse("A*02:629") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:629") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_63():
    result = parse("A*02:63")
    assert result.__class__ is Allele, f'Expected parse("A*02:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_630():
    result = parse("A*02:630")
    assert result.__class__ is Allele, f'Expected parse("A*02:630") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:630") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_631():
    result = parse("A*02:631")
    assert result.__class__ is Allele, f'Expected parse("A*02:631") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:631") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_632():
    result = parse("A*02:632")
    assert result.__class__ is Allele, f'Expected parse("A*02:632") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:632") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_633():
    result = parse("A*02:633")
    assert result.__class__ is Allele, f'Expected parse("A*02:633") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:633") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_634():
    result = parse("A*02:634")
    assert result.__class__ is Allele, f'Expected parse("A*02:634") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:634") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_635():
    result = parse("A*02:635")
    assert result.__class__ is Allele, f'Expected parse("A*02:635") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:635") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_636():
    result = parse("A*02:636")
    assert result.__class__ is Allele, f'Expected parse("A*02:636") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:636") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_637():
    result = parse("A*02:637")
    assert result.__class__ is Allele, f'Expected parse("A*02:637") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:637") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_638():
    result = parse("A*02:638")
    assert result.__class__ is Allele, f'Expected parse("A*02:638") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:638") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_639():
    result = parse("A*02:639")
    assert result.__class__ is Allele, f'Expected parse("A*02:639") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:639") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_640():
    result = parse("A*02:640")
    assert result.__class__ is Allele, f'Expected parse("A*02:640") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:640") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_641():
    result = parse("A*02:641")
    assert result.__class__ is Allele, f'Expected parse("A*02:641") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:641") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_642():
    result = parse("A*02:642")
    assert result.__class__ is Allele, f'Expected parse("A*02:642") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:642") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_643N():
    result = parse("A*02:643N")
    assert result.__class__ is Allele, f'Expected parse("A*02:643N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:643N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_644():
    result = parse("A*02:644")
    assert result.__class__ is Allele, f'Expected parse("A*02:644") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:644") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_645():
    result = parse("A*02:645")
    assert result.__class__ is Allele, f'Expected parse("A*02:645") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:645") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_646():
    result = parse("A*02:646")
    assert result.__class__ is Allele, f'Expected parse("A*02:646") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:646") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_647():
    result = parse("A*02:647")
    assert result.__class__ is Allele, f'Expected parse("A*02:647") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:647") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_648_01():
    result = parse("A*02:648:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:648:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:648:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_648_02():
    result = parse("A*02:648:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:648:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:648:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_649():
    result = parse("A*02:649")
    assert result.__class__ is Allele, f'Expected parse("A*02:649") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:649") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_64_01():
    result = parse("A*02:64:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:64:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:64:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_64_02():
    result = parse("A*02:64:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:64:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:64:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_65():
    result = parse("A*02:65")
    assert result.__class__ is Allele, f'Expected parse("A*02:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_650():
    result = parse("A*02:650")
    assert result.__class__ is Allele, f'Expected parse("A*02:650") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:650") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_651():
    result = parse("A*02:651")
    assert result.__class__ is Allele, f'Expected parse("A*02:651") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:651") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_652():
    result = parse("A*02:652")
    assert result.__class__ is Allele, f'Expected parse("A*02:652") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:652") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_653():
    result = parse("A*02:653")
    assert result.__class__ is Allele, f'Expected parse("A*02:653") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:653") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_654():
    result = parse("A*02:654")
    assert result.__class__ is Allele, f'Expected parse("A*02:654") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:654") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_655():
    result = parse("A*02:655")
    assert result.__class__ is Allele, f'Expected parse("A*02:655") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:655") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_656():
    result = parse("A*02:656")
    assert result.__class__ is Allele, f'Expected parse("A*02:656") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:656") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_657():
    result = parse("A*02:657")
    assert result.__class__ is Allele, f'Expected parse("A*02:657") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:657") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_658():
    result = parse("A*02:658")
    assert result.__class__ is Allele, f'Expected parse("A*02:658") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:658") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_659():
    result = parse("A*02:659")
    assert result.__class__ is Allele, f'Expected parse("A*02:659") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:659") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_66():
    result = parse("A*02:66")
    assert result.__class__ is Allele, f'Expected parse("A*02:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_660():
    result = parse("A*02:660")
    assert result.__class__ is Allele, f'Expected parse("A*02:660") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:660") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_661():
    result = parse("A*02:661")
    assert result.__class__ is Allele, f'Expected parse("A*02:661") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:661") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_662():
    result = parse("A*02:662")
    assert result.__class__ is Allele, f'Expected parse("A*02:662") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:662") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_663():
    result = parse("A*02:663")
    assert result.__class__ is Allele, f'Expected parse("A*02:663") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:663") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_664():
    result = parse("A*02:664")
    assert result.__class__ is Allele, f'Expected parse("A*02:664") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:664") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_665():
    result = parse("A*02:665")
    assert result.__class__ is Allele, f'Expected parse("A*02:665") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:665") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_666():
    result = parse("A*02:666")
    assert result.__class__ is Allele, f'Expected parse("A*02:666") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:666") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_667():
    result = parse("A*02:667")
    assert result.__class__ is Allele, f'Expected parse("A*02:667") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:667") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_668():
    result = parse("A*02:668")
    assert result.__class__ is Allele, f'Expected parse("A*02:668") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:668") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_669():
    result = parse("A*02:669")
    assert result.__class__ is Allele, f'Expected parse("A*02:669") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:669") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_67():
    result = parse("A*02:67")
    assert result.__class__ is Allele, f'Expected parse("A*02:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_670():
    result = parse("A*02:670")
    assert result.__class__ is Allele, f'Expected parse("A*02:670") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:670") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_671():
    result = parse("A*02:671")
    assert result.__class__ is Allele, f'Expected parse("A*02:671") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:671") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_672Q():
    result = parse("A*02:672Q")
    assert result.__class__ is Allele, f'Expected parse("A*02:672Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:672Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_673():
    result = parse("A*02:673")
    assert result.__class__ is Allele, f'Expected parse("A*02:673") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:673") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_674():
    result = parse("A*02:674")
    assert result.__class__ is Allele, f'Expected parse("A*02:674") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:674") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_675N():
    result = parse("A*02:675N")
    assert result.__class__ is Allele, f'Expected parse("A*02:675N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:675N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_676():
    result = parse("A*02:676")
    assert result.__class__ is Allele, f'Expected parse("A*02:676") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:676") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_677():
    result = parse("A*02:677")
    assert result.__class__ is Allele, f'Expected parse("A*02:677") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:677") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_678():
    result = parse("A*02:678")
    assert result.__class__ is Allele, f'Expected parse("A*02:678") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:678") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_679():
    result = parse("A*02:679")
    assert result.__class__ is Allele, f'Expected parse("A*02:679") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:679") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_68():
    result = parse("A*02:68")
    assert result.__class__ is Allele, f'Expected parse("A*02:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_680():
    result = parse("A*02:680")
    assert result.__class__ is Allele, f'Expected parse("A*02:680") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:680") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_681():
    result = parse("A*02:681")
    assert result.__class__ is Allele, f'Expected parse("A*02:681") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:681") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_682():
    result = parse("A*02:682")
    assert result.__class__ is Allele, f'Expected parse("A*02:682") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:682") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_683():
    result = parse("A*02:683")
    assert result.__class__ is Allele, f'Expected parse("A*02:683") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:683") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_684():
    result = parse("A*02:684")
    assert result.__class__ is Allele, f'Expected parse("A*02:684") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:684") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_685():
    result = parse("A*02:685")
    assert result.__class__ is Allele, f'Expected parse("A*02:685") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:685") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_686():
    result = parse("A*02:686")
    assert result.__class__ is Allele, f'Expected parse("A*02:686") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:686") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_687():
    result = parse("A*02:687")
    assert result.__class__ is Allele, f'Expected parse("A*02:687") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:687") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_688_01():
    result = parse("A*02:688:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:688:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:688:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_688_02():
    result = parse("A*02:688:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:688:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:688:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_689():
    result = parse("A*02:689")
    assert result.__class__ is Allele, f'Expected parse("A*02:689") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:689") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_69():
    result = parse("A*02:69")
    assert result.__class__ is Allele, f'Expected parse("A*02:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_690():
    result = parse("A*02:690")
    assert result.__class__ is Allele, f'Expected parse("A*02:690") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:690") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_691N():
    result = parse("A*02:691N")
    assert result.__class__ is Allele, f'Expected parse("A*02:691N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:691N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_692():
    result = parse("A*02:692")
    assert result.__class__ is Allele, f'Expected parse("A*02:692") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:692") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_693():
    result = parse("A*02:693")
    assert result.__class__ is Allele, f'Expected parse("A*02:693") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:693") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_694():
    result = parse("A*02:694")
    assert result.__class__ is Allele, f'Expected parse("A*02:694") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:694") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_695():
    result = parse("A*02:695")
    assert result.__class__ is Allele, f'Expected parse("A*02:695") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:695") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_696N():
    result = parse("A*02:696N")
    assert result.__class__ is Allele, f'Expected parse("A*02:696N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:696N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_697():
    result = parse("A*02:697")
    assert result.__class__ is Allele, f'Expected parse("A*02:697") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:697") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_698():
    result = parse("A*02:698")
    assert result.__class__ is Allele, f'Expected parse("A*02:698") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:698") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_699():
    result = parse("A*02:699")
    assert result.__class__ is Allele, f'Expected parse("A*02:699") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:699") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_70():
    result = parse("A*02:70")
    assert result.__class__ is Allele, f'Expected parse("A*02:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_700():
    result = parse("A*02:700")
    assert result.__class__ is Allele, f'Expected parse("A*02:700") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:700") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_701():
    result = parse("A*02:701")
    assert result.__class__ is Allele, f'Expected parse("A*02:701") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:701") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_702():
    result = parse("A*02:702")
    assert result.__class__ is Allele, f'Expected parse("A*02:702") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:702") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_703():
    result = parse("A*02:703")
    assert result.__class__ is Allele, f'Expected parse("A*02:703") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:703") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_704():
    result = parse("A*02:704")
    assert result.__class__ is Allele, f'Expected parse("A*02:704") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:704") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_705():
    result = parse("A*02:705")
    assert result.__class__ is Allele, f'Expected parse("A*02:705") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:705") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_706():
    result = parse("A*02:706")
    assert result.__class__ is Allele, f'Expected parse("A*02:706") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:706") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_707():
    result = parse("A*02:707")
    assert result.__class__ is Allele, f'Expected parse("A*02:707") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:707") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_708():
    result = parse("A*02:708")
    assert result.__class__ is Allele, f'Expected parse("A*02:708") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:708") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_709():
    result = parse("A*02:709")
    assert result.__class__ is Allele, f'Expected parse("A*02:709") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:709") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_71():
    result = parse("A*02:71")
    assert result.__class__ is Allele, f'Expected parse("A*02:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_710N():
    result = parse("A*02:710N")
    assert result.__class__ is Allele, f'Expected parse("A*02:710N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:710N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_711():
    result = parse("A*02:711")
    assert result.__class__ is Allele, f'Expected parse("A*02:711") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:711") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_712():
    result = parse("A*02:712")
    assert result.__class__ is Allele, f'Expected parse("A*02:712") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:712") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_713():
    result = parse("A*02:713")
    assert result.__class__ is Allele, f'Expected parse("A*02:713") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:713") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_714():
    result = parse("A*02:714")
    assert result.__class__ is Allele, f'Expected parse("A*02:714") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:714") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_715N():
    result = parse("A*02:715N")
    assert result.__class__ is Allele, f'Expected parse("A*02:715N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:715N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_716():
    result = parse("A*02:716")
    assert result.__class__ is Allele, f'Expected parse("A*02:716") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:716") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_717():
    result = parse("A*02:717")
    assert result.__class__ is Allele, f'Expected parse("A*02:717") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:717") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_718():
    result = parse("A*02:718")
    assert result.__class__ is Allele, f'Expected parse("A*02:718") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:718") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_719():
    result = parse("A*02:719")
    assert result.__class__ is Allele, f'Expected parse("A*02:719") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:719") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_72():
    result = parse("A*02:72")
    assert result.__class__ is Allele, f'Expected parse("A*02:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_720():
    result = parse("A*02:720")
    assert result.__class__ is Allele, f'Expected parse("A*02:720") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:720") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_721():
    result = parse("A*02:721")
    assert result.__class__ is Allele, f'Expected parse("A*02:721") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:721") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_722():
    result = parse("A*02:722")
    assert result.__class__ is Allele, f'Expected parse("A*02:722") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:722") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_723():
    result = parse("A*02:723")
    assert result.__class__ is Allele, f'Expected parse("A*02:723") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:723") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_724():
    result = parse("A*02:724")
    assert result.__class__ is Allele, f'Expected parse("A*02:724") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:724") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_725():
    result = parse("A*02:725")
    assert result.__class__ is Allele, f'Expected parse("A*02:725") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:725") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_726():
    result = parse("A*02:726")
    assert result.__class__ is Allele, f'Expected parse("A*02:726") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:726") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_727():
    result = parse("A*02:727")
    assert result.__class__ is Allele, f'Expected parse("A*02:727") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:727") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_728Q():
    result = parse("A*02:728Q")
    assert result.__class__ is Allele, f'Expected parse("A*02:728Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:728Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_729():
    result = parse("A*02:729")
    assert result.__class__ is Allele, f'Expected parse("A*02:729") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:729") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_73():
    result = parse("A*02:73")
    assert result.__class__ is Allele, f'Expected parse("A*02:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_730():
    result = parse("A*02:730")
    assert result.__class__ is Allele, f'Expected parse("A*02:730") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:730") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_731():
    result = parse("A*02:731")
    assert result.__class__ is Allele, f'Expected parse("A*02:731") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:731") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_732():
    result = parse("A*02:732")
    assert result.__class__ is Allele, f'Expected parse("A*02:732") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:732") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_733():
    result = parse("A*02:733")
    assert result.__class__ is Allele, f'Expected parse("A*02:733") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:733") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_734():
    result = parse("A*02:734")
    assert result.__class__ is Allele, f'Expected parse("A*02:734") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:734") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_735():
    result = parse("A*02:735")
    assert result.__class__ is Allele, f'Expected parse("A*02:735") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:735") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_736():
    result = parse("A*02:736")
    assert result.__class__ is Allele, f'Expected parse("A*02:736") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:736") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_737():
    result = parse("A*02:737")
    assert result.__class__ is Allele, f'Expected parse("A*02:737") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:737") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_738():
    result = parse("A*02:738")
    assert result.__class__ is Allele, f'Expected parse("A*02:738") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:738") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_739():
    result = parse("A*02:739")
    assert result.__class__ is Allele, f'Expected parse("A*02:739") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:739") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_740():
    result = parse("A*02:740")
    assert result.__class__ is Allele, f'Expected parse("A*02:740") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:740") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_741():
    result = parse("A*02:741")
    assert result.__class__ is Allele, f'Expected parse("A*02:741") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:741") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_742():
    result = parse("A*02:742")
    assert result.__class__ is Allele, f'Expected parse("A*02:742") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:742") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_743():
    result = parse("A*02:743")
    assert result.__class__ is Allele, f'Expected parse("A*02:743") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:743") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_744():
    result = parse("A*02:744")
    assert result.__class__ is Allele, f'Expected parse("A*02:744") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:744") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_745():
    result = parse("A*02:745")
    assert result.__class__ is Allele, f'Expected parse("A*02:745") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:745") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_746():
    result = parse("A*02:746")
    assert result.__class__ is Allele, f'Expected parse("A*02:746") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:746") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_747():
    result = parse("A*02:747")
    assert result.__class__ is Allele, f'Expected parse("A*02:747") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:747") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_748N():
    result = parse("A*02:748N")
    assert result.__class__ is Allele, f'Expected parse("A*02:748N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:748N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_749():
    result = parse("A*02:749")
    assert result.__class__ is Allele, f'Expected parse("A*02:749") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:749") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_74_01():
    result = parse("A*02:74:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:74:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:74:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_74_02():
    result = parse("A*02:74:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:74:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:74:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_75():
    result = parse("A*02:75")
    assert result.__class__ is Allele, f'Expected parse("A*02:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_750():
    result = parse("A*02:750")
    assert result.__class__ is Allele, f'Expected parse("A*02:750") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:750") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_751():
    result = parse("A*02:751")
    assert result.__class__ is Allele, f'Expected parse("A*02:751") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:751") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_752():
    result = parse("A*02:752")
    assert result.__class__ is Allele, f'Expected parse("A*02:752") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:752") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_753():
    result = parse("A*02:753")
    assert result.__class__ is Allele, f'Expected parse("A*02:753") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:753") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_754():
    result = parse("A*02:754")
    assert result.__class__ is Allele, f'Expected parse("A*02:754") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:754") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_755():
    result = parse("A*02:755")
    assert result.__class__ is Allele, f'Expected parse("A*02:755") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:755") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_756():
    result = parse("A*02:756")
    assert result.__class__ is Allele, f'Expected parse("A*02:756") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:756") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_757():
    result = parse("A*02:757")
    assert result.__class__ is Allele, f'Expected parse("A*02:757") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:757") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_758():
    result = parse("A*02:758")
    assert result.__class__ is Allele, f'Expected parse("A*02:758") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:758") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_759():
    result = parse("A*02:759")
    assert result.__class__ is Allele, f'Expected parse("A*02:759") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:759") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_760N():
    result = parse("A*02:760N")
    assert result.__class__ is Allele, f'Expected parse("A*02:760N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:760N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_761():
    result = parse("A*02:761")
    assert result.__class__ is Allele, f'Expected parse("A*02:761") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:761") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_762():
    result = parse("A*02:762")
    assert result.__class__ is Allele, f'Expected parse("A*02:762") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:762") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_763():
    result = parse("A*02:763")
    assert result.__class__ is Allele, f'Expected parse("A*02:763") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:763") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_764():
    result = parse("A*02:764")
    assert result.__class__ is Allele, f'Expected parse("A*02:764") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:764") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_765():
    result = parse("A*02:765")
    assert result.__class__ is Allele, f'Expected parse("A*02:765") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:765") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_766():
    result = parse("A*02:766")
    assert result.__class__ is Allele, f'Expected parse("A*02:766") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:766") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_767():
    result = parse("A*02:767")
    assert result.__class__ is Allele, f'Expected parse("A*02:767") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:767") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_768():
    result = parse("A*02:768")
    assert result.__class__ is Allele, f'Expected parse("A*02:768") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:768") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_769():
    result = parse("A*02:769")
    assert result.__class__ is Allele, f'Expected parse("A*02:769") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:769") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_76_01():
    result = parse("A*02:76:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:76:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:76:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_76_02():
    result = parse("A*02:76:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:76:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:76:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_77():
    result = parse("A*02:77")
    assert result.__class__ is Allele, f'Expected parse("A*02:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_770():
    result = parse("A*02:770")
    assert result.__class__ is Allele, f'Expected parse("A*02:770") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:770") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_771():
    result = parse("A*02:771")
    assert result.__class__ is Allele, f'Expected parse("A*02:771") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:771") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_772():
    result = parse("A*02:772")
    assert result.__class__ is Allele, f'Expected parse("A*02:772") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:772") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_773N():
    result = parse("A*02:773N")
    assert result.__class__ is Allele, f'Expected parse("A*02:773N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:773N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_774():
    result = parse("A*02:774")
    assert result.__class__ is Allele, f'Expected parse("A*02:774") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:774") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_775N():
    result = parse("A*02:775N")
    assert result.__class__ is Allele, f'Expected parse("A*02:775N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:775N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_776():
    result = parse("A*02:776")
    assert result.__class__ is Allele, f'Expected parse("A*02:776") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:776") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_777():
    result = parse("A*02:777")
    assert result.__class__ is Allele, f'Expected parse("A*02:777") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:777") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_778():
    result = parse("A*02:778")
    assert result.__class__ is Allele, f'Expected parse("A*02:778") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:778") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_779():
    result = parse("A*02:779")
    assert result.__class__ is Allele, f'Expected parse("A*02:779") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:779") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_78():
    result = parse("A*02:78")
    assert result.__class__ is Allele, f'Expected parse("A*02:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_780():
    result = parse("A*02:780")
    assert result.__class__ is Allele, f'Expected parse("A*02:780") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:780") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_781():
    result = parse("A*02:781")
    assert result.__class__ is Allele, f'Expected parse("A*02:781") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:781") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_782():
    result = parse("A*02:782")
    assert result.__class__ is Allele, f'Expected parse("A*02:782") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:782") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_783():
    result = parse("A*02:783")
    assert result.__class__ is Allele, f'Expected parse("A*02:783") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:783") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_784():
    result = parse("A*02:784")
    assert result.__class__ is Allele, f'Expected parse("A*02:784") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:784") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_785():
    result = parse("A*02:785")
    assert result.__class__ is Allele, f'Expected parse("A*02:785") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:785") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_786():
    result = parse("A*02:786")
    assert result.__class__ is Allele, f'Expected parse("A*02:786") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:786") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_787():
    result = parse("A*02:787")
    assert result.__class__ is Allele, f'Expected parse("A*02:787") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:787") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_788N():
    result = parse("A*02:788N")
    assert result.__class__ is Allele, f'Expected parse("A*02:788N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:788N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_789N():
    result = parse("A*02:789N")
    assert result.__class__ is Allele, f'Expected parse("A*02:789N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:789N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_790():
    result = parse("A*02:790")
    assert result.__class__ is Allele, f'Expected parse("A*02:790") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:790") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_791N():
    result = parse("A*02:791N")
    assert result.__class__ is Allele, f'Expected parse("A*02:791N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:791N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_792N():
    result = parse("A*02:792N")
    assert result.__class__ is Allele, f'Expected parse("A*02:792N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:792N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_793N():
    result = parse("A*02:793N")
    assert result.__class__ is Allele, f'Expected parse("A*02:793N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:793N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_794():
    result = parse("A*02:794")
    assert result.__class__ is Allele, f'Expected parse("A*02:794") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:794") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_795Q():
    result = parse("A*02:795Q")
    assert result.__class__ is Allele, f'Expected parse("A*02:795Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:795Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_796N():
    result = parse("A*02:796N")
    assert result.__class__ is Allele, f'Expected parse("A*02:796N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:796N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_797N():
    result = parse("A*02:797N")
    assert result.__class__ is Allele, f'Expected parse("A*02:797N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:797N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_798():
    result = parse("A*02:798")
    assert result.__class__ is Allele, f'Expected parse("A*02:798") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:798") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_799():
    result = parse("A*02:799")
    assert result.__class__ is Allele, f'Expected parse("A*02:799") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:799") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_79_01():
    result = parse("A*02:79:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:79:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:79:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_79_02():
    result = parse("A*02:79:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:79:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:79:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_80():
    result = parse("A*02:80")
    assert result.__class__ is Allele, f'Expected parse("A*02:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_800():
    result = parse("A*02:800")
    assert result.__class__ is Allele, f'Expected parse("A*02:800") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:800") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_801():
    result = parse("A*02:801")
    assert result.__class__ is Allele, f'Expected parse("A*02:801") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:801") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_802():
    result = parse("A*02:802")
    assert result.__class__ is Allele, f'Expected parse("A*02:802") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:802") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_803N():
    result = parse("A*02:803N")
    assert result.__class__ is Allele, f'Expected parse("A*02:803N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:803N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_804():
    result = parse("A*02:804")
    assert result.__class__ is Allele, f'Expected parse("A*02:804") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:804") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_805Q():
    result = parse("A*02:805Q")
    assert result.__class__ is Allele, f'Expected parse("A*02:805Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:805Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_806N():
    result = parse("A*02:806N")
    assert result.__class__ is Allele, f'Expected parse("A*02:806N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:806N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_807N():
    result = parse("A*02:807N")
    assert result.__class__ is Allele, f'Expected parse("A*02:807N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:807N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_808():
    result = parse("A*02:808")
    assert result.__class__ is Allele, f'Expected parse("A*02:808") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:808") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_809():
    result = parse("A*02:809")
    assert result.__class__ is Allele, f'Expected parse("A*02:809") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:809") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_81():
    result = parse("A*02:81")
    assert result.__class__ is Allele, f'Expected parse("A*02:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_810():
    result = parse("A*02:810")
    assert result.__class__ is Allele, f'Expected parse("A*02:810") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:810") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_811():
    result = parse("A*02:811")
    assert result.__class__ is Allele, f'Expected parse("A*02:811") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:811") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_812():
    result = parse("A*02:812")
    assert result.__class__ is Allele, f'Expected parse("A*02:812") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:812") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_813():
    result = parse("A*02:813")
    assert result.__class__ is Allele, f'Expected parse("A*02:813") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:813") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_814():
    result = parse("A*02:814")
    assert result.__class__ is Allele, f'Expected parse("A*02:814") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:814") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_815():
    result = parse("A*02:815")
    assert result.__class__ is Allele, f'Expected parse("A*02:815") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:815") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_816():
    result = parse("A*02:816")
    assert result.__class__ is Allele, f'Expected parse("A*02:816") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:816") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_817():
    result = parse("A*02:817")
    assert result.__class__ is Allele, f'Expected parse("A*02:817") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:817") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_818():
    result = parse("A*02:818")
    assert result.__class__ is Allele, f'Expected parse("A*02:818") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:818") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_819():
    result = parse("A*02:819")
    assert result.__class__ is Allele, f'Expected parse("A*02:819") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:819") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_820():
    result = parse("A*02:820")
    assert result.__class__ is Allele, f'Expected parse("A*02:820") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:820") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_821():
    result = parse("A*02:821")
    assert result.__class__ is Allele, f'Expected parse("A*02:821") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:821") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_822():
    result = parse("A*02:822")
    assert result.__class__ is Allele, f'Expected parse("A*02:822") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:822") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_823():
    result = parse("A*02:823")
    assert result.__class__ is Allele, f'Expected parse("A*02:823") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:823") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_824():
    result = parse("A*02:824")
    assert result.__class__ is Allele, f'Expected parse("A*02:824") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:824") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_825():
    result = parse("A*02:825")
    assert result.__class__ is Allele, f'Expected parse("A*02:825") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:825") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_826Q():
    result = parse("A*02:826Q")
    assert result.__class__ is Allele, f'Expected parse("A*02:826Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:826Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_827Q():
    result = parse("A*02:827Q")
    assert result.__class__ is Allele, f'Expected parse("A*02:827Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:827Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_828():
    result = parse("A*02:828")
    assert result.__class__ is Allele, f'Expected parse("A*02:828") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:828") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_829():
    result = parse("A*02:829")
    assert result.__class__ is Allele, f'Expected parse("A*02:829") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:829") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_82N():
    result = parse("A*02:82N")
    assert result.__class__ is Allele, f'Expected parse("A*02:82N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:82N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_830():
    result = parse("A*02:830")
    assert result.__class__ is Allele, f'Expected parse("A*02:830") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:830") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_831N():
    result = parse("A*02:831N")
    assert result.__class__ is Allele, f'Expected parse("A*02:831N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:831N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_832N():
    result = parse("A*02:832N")
    assert result.__class__ is Allele, f'Expected parse("A*02:832N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:832N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_833N():
    result = parse("A*02:833N")
    assert result.__class__ is Allele, f'Expected parse("A*02:833N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:833N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_834():
    result = parse("A*02:834")
    assert result.__class__ is Allele, f'Expected parse("A*02:834") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:834") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_835():
    result = parse("A*02:835")
    assert result.__class__ is Allele, f'Expected parse("A*02:835") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:835") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_836():
    result = parse("A*02:836")
    assert result.__class__ is Allele, f'Expected parse("A*02:836") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:836") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_837():
    result = parse("A*02:837")
    assert result.__class__ is Allele, f'Expected parse("A*02:837") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:837") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_838():
    result = parse("A*02:838")
    assert result.__class__ is Allele, f'Expected parse("A*02:838") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:838") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_839():
    result = parse("A*02:839")
    assert result.__class__ is Allele, f'Expected parse("A*02:839") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:839") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_83N():
    result = parse("A*02:83N")
    assert result.__class__ is Allele, f'Expected parse("A*02:83N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:83N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_84():
    result = parse("A*02:84")
    assert result.__class__ is Allele, f'Expected parse("A*02:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_840():
    result = parse("A*02:840")
    assert result.__class__ is Allele, f'Expected parse("A*02:840") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:840") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_841():
    result = parse("A*02:841")
    assert result.__class__ is Allele, f'Expected parse("A*02:841") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:841") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_842():
    result = parse("A*02:842")
    assert result.__class__ is Allele, f'Expected parse("A*02:842") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:842") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_843():
    result = parse("A*02:843")
    assert result.__class__ is Allele, f'Expected parse("A*02:843") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:843") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_844():
    result = parse("A*02:844")
    assert result.__class__ is Allele, f'Expected parse("A*02:844") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:844") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_845():
    result = parse("A*02:845")
    assert result.__class__ is Allele, f'Expected parse("A*02:845") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:845") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_846():
    result = parse("A*02:846")
    assert result.__class__ is Allele, f'Expected parse("A*02:846") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:846") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_847():
    result = parse("A*02:847")
    assert result.__class__ is Allele, f'Expected parse("A*02:847") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:847") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_848():
    result = parse("A*02:848")
    assert result.__class__ is Allele, f'Expected parse("A*02:848") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:848") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_849():
    result = parse("A*02:849")
    assert result.__class__ is Allele, f'Expected parse("A*02:849") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:849") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_85():
    result = parse("A*02:85")
    assert result.__class__ is Allele, f'Expected parse("A*02:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_850():
    result = parse("A*02:850")
    assert result.__class__ is Allele, f'Expected parse("A*02:850") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:850") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_851():
    result = parse("A*02:851")
    assert result.__class__ is Allele, f'Expected parse("A*02:851") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:851") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_852():
    result = parse("A*02:852")
    assert result.__class__ is Allele, f'Expected parse("A*02:852") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:852") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_853():
    result = parse("A*02:853")
    assert result.__class__ is Allele, f'Expected parse("A*02:853") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:853") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_854():
    result = parse("A*02:854")
    assert result.__class__ is Allele, f'Expected parse("A*02:854") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:854") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_855():
    result = parse("A*02:855")
    assert result.__class__ is Allele, f'Expected parse("A*02:855") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:855") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_856():
    result = parse("A*02:856")
    assert result.__class__ is Allele, f'Expected parse("A*02:856") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:856") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_857():
    result = parse("A*02:857")
    assert result.__class__ is Allele, f'Expected parse("A*02:857") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:857") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_858N():
    result = parse("A*02:858N")
    assert result.__class__ is Allele, f'Expected parse("A*02:858N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:858N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_859():
    result = parse("A*02:859")
    assert result.__class__ is Allele, f'Expected parse("A*02:859") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:859") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_860():
    result = parse("A*02:860")
    assert result.__class__ is Allele, f'Expected parse("A*02:860") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:860") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_861():
    result = parse("A*02:861")
    assert result.__class__ is Allele, f'Expected parse("A*02:861") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:861") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_862():
    result = parse("A*02:862")
    assert result.__class__ is Allele, f'Expected parse("A*02:862") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:862") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_863():
    result = parse("A*02:863")
    assert result.__class__ is Allele, f'Expected parse("A*02:863") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:863") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_864_01_01():
    result = parse("A*02:864:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:864:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:864:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_864_01_02():
    result = parse("A*02:864:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*02:864:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*02:864:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_865():
    result = parse("A*02:865")
    assert result.__class__ is Allele, f'Expected parse("A*02:865") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:865") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_866():
    result = parse("A*02:866")
    assert result.__class__ is Allele, f'Expected parse("A*02:866") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:866") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_867():
    result = parse("A*02:867")
    assert result.__class__ is Allele, f'Expected parse("A*02:867") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:867") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_868():
    result = parse("A*02:868")
    assert result.__class__ is Allele, f'Expected parse("A*02:868") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:868") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_869():
    result = parse("A*02:869")
    assert result.__class__ is Allele, f'Expected parse("A*02:869") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:869") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_86_01():
    result = parse("A*02:86:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:86:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:86:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_86_02():
    result = parse("A*02:86:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:86:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:86:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_87():
    result = parse("A*02:87")
    assert result.__class__ is Allele, f'Expected parse("A*02:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_870():
    result = parse("A*02:870")
    assert result.__class__ is Allele, f'Expected parse("A*02:870") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:870") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_871N():
    result = parse("A*02:871N")
    assert result.__class__ is Allele, f'Expected parse("A*02:871N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:871N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_872():
    result = parse("A*02:872")
    assert result.__class__ is Allele, f'Expected parse("A*02:872") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:872") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_873():
    result = parse("A*02:873")
    assert result.__class__ is Allele, f'Expected parse("A*02:873") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:873") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_874():
    result = parse("A*02:874")
    assert result.__class__ is Allele, f'Expected parse("A*02:874") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:874") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_875():
    result = parse("A*02:875")
    assert result.__class__ is Allele, f'Expected parse("A*02:875") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:875") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_876():
    result = parse("A*02:876")
    assert result.__class__ is Allele, f'Expected parse("A*02:876") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:876") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_877():
    result = parse("A*02:877")
    assert result.__class__ is Allele, f'Expected parse("A*02:877") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:877") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_878():
    result = parse("A*02:878")
    assert result.__class__ is Allele, f'Expected parse("A*02:878") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:878") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_879N():
    result = parse("A*02:879N")
    assert result.__class__ is Allele, f'Expected parse("A*02:879N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:879N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_880N():
    result = parse("A*02:880N")
    assert result.__class__ is Allele, f'Expected parse("A*02:880N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:880N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_881():
    result = parse("A*02:881")
    assert result.__class__ is Allele, f'Expected parse("A*02:881") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:881") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_882():
    result = parse("A*02:882")
    assert result.__class__ is Allele, f'Expected parse("A*02:882") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:882") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_883():
    result = parse("A*02:883")
    assert result.__class__ is Allele, f'Expected parse("A*02:883") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:883") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_884():
    result = parse("A*02:884")
    assert result.__class__ is Allele, f'Expected parse("A*02:884") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:884") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_885():
    result = parse("A*02:885")
    assert result.__class__ is Allele, f'Expected parse("A*02:885") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:885") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_886():
    result = parse("A*02:886")
    assert result.__class__ is Allele, f'Expected parse("A*02:886") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:886") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_887N():
    result = parse("A*02:887N")
    assert result.__class__ is Allele, f'Expected parse("A*02:887N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:887N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_888():
    result = parse("A*02:888")
    assert result.__class__ is Allele, f'Expected parse("A*02:888") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:888") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_889():
    result = parse("A*02:889")
    assert result.__class__ is Allele, f'Expected parse("A*02:889") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:889") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_88N():
    result = parse("A*02:88N")
    assert result.__class__ is Allele, f'Expected parse("A*02:88N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:88N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_890():
    result = parse("A*02:890")
    assert result.__class__ is Allele, f'Expected parse("A*02:890") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:890") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_891():
    result = parse("A*02:891")
    assert result.__class__ is Allele, f'Expected parse("A*02:891") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:891") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_892():
    result = parse("A*02:892")
    assert result.__class__ is Allele, f'Expected parse("A*02:892") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:892") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_893():
    result = parse("A*02:893")
    assert result.__class__ is Allele, f'Expected parse("A*02:893") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:893") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_894():
    result = parse("A*02:894")
    assert result.__class__ is Allele, f'Expected parse("A*02:894") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:894") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_895N():
    result = parse("A*02:895N")
    assert result.__class__ is Allele, f'Expected parse("A*02:895N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:895N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_896N():
    result = parse("A*02:896N")
    assert result.__class__ is Allele, f'Expected parse("A*02:896N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:896N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_897():
    result = parse("A*02:897")
    assert result.__class__ is Allele, f'Expected parse("A*02:897") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:897") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_898():
    result = parse("A*02:898")
    assert result.__class__ is Allele, f'Expected parse("A*02:898") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:898") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_899():
    result = parse("A*02:899")
    assert result.__class__ is Allele, f'Expected parse("A*02:899") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:899") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_89_01():
    result = parse("A*02:89:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:89:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:89:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_89_02():
    result = parse("A*02:89:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:89:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:89:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_90():
    result = parse("A*02:90")
    assert result.__class__ is Allele, f'Expected parse("A*02:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_900():
    result = parse("A*02:900")
    assert result.__class__ is Allele, f'Expected parse("A*02:900") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:900") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_901():
    result = parse("A*02:901")
    assert result.__class__ is Allele, f'Expected parse("A*02:901") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:901") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_902():
    result = parse("A*02:902")
    assert result.__class__ is Allele, f'Expected parse("A*02:902") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:902") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_903():
    result = parse("A*02:903")
    assert result.__class__ is Allele, f'Expected parse("A*02:903") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:903") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_904():
    result = parse("A*02:904")
    assert result.__class__ is Allele, f'Expected parse("A*02:904") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:904") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_905():
    result = parse("A*02:905")
    assert result.__class__ is Allele, f'Expected parse("A*02:905") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:905") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_906():
    result = parse("A*02:906")
    assert result.__class__ is Allele, f'Expected parse("A*02:906") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:906") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_907():
    result = parse("A*02:907")
    assert result.__class__ is Allele, f'Expected parse("A*02:907") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:907") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_908():
    result = parse("A*02:908")
    assert result.__class__ is Allele, f'Expected parse("A*02:908") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:908") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_909():
    result = parse("A*02:909")
    assert result.__class__ is Allele, f'Expected parse("A*02:909") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:909") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_91():
    result = parse("A*02:91")
    assert result.__class__ is Allele, f'Expected parse("A*02:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_910():
    result = parse("A*02:910")
    assert result.__class__ is Allele, f'Expected parse("A*02:910") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:910") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_911():
    result = parse("A*02:911")
    assert result.__class__ is Allele, f'Expected parse("A*02:911") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:911") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_912():
    result = parse("A*02:912")
    assert result.__class__ is Allele, f'Expected parse("A*02:912") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:912") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_913():
    result = parse("A*02:913")
    assert result.__class__ is Allele, f'Expected parse("A*02:913") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:913") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_914():
    result = parse("A*02:914")
    assert result.__class__ is Allele, f'Expected parse("A*02:914") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:914") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_915N():
    result = parse("A*02:915N")
    assert result.__class__ is Allele, f'Expected parse("A*02:915N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:915N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_916():
    result = parse("A*02:916")
    assert result.__class__ is Allele, f'Expected parse("A*02:916") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:916") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_917():
    result = parse("A*02:917")
    assert result.__class__ is Allele, f'Expected parse("A*02:917") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:917") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_918():
    result = parse("A*02:918")
    assert result.__class__ is Allele, f'Expected parse("A*02:918") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:918") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_919():
    result = parse("A*02:919")
    assert result.__class__ is Allele, f'Expected parse("A*02:919") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:919") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_92():
    result = parse("A*02:92")
    assert result.__class__ is Allele, f'Expected parse("A*02:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_920():
    result = parse("A*02:920")
    assert result.__class__ is Allele, f'Expected parse("A*02:920") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:920") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_921():
    result = parse("A*02:921")
    assert result.__class__ is Allele, f'Expected parse("A*02:921") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:921") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_922():
    result = parse("A*02:922")
    assert result.__class__ is Allele, f'Expected parse("A*02:922") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:922") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_923():
    result = parse("A*02:923")
    assert result.__class__ is Allele, f'Expected parse("A*02:923") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:923") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_924():
    result = parse("A*02:924")
    assert result.__class__ is Allele, f'Expected parse("A*02:924") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:924") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_925():
    result = parse("A*02:925")
    assert result.__class__ is Allele, f'Expected parse("A*02:925") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:925") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_926():
    result = parse("A*02:926")
    assert result.__class__ is Allele, f'Expected parse("A*02:926") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:926") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_927():
    result = parse("A*02:927")
    assert result.__class__ is Allele, f'Expected parse("A*02:927") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:927") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_928():
    result = parse("A*02:928")
    assert result.__class__ is Allele, f'Expected parse("A*02:928") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:928") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_929():
    result = parse("A*02:929")
    assert result.__class__ is Allele, f'Expected parse("A*02:929") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:929") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_930():
    result = parse("A*02:930")
    assert result.__class__ is Allele, f'Expected parse("A*02:930") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:930") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_931():
    result = parse("A*02:931")
    assert result.__class__ is Allele, f'Expected parse("A*02:931") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:931") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_932():
    result = parse("A*02:932")
    assert result.__class__ is Allele, f'Expected parse("A*02:932") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:932") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_933():
    result = parse("A*02:933")
    assert result.__class__ is Allele, f'Expected parse("A*02:933") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:933") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_934():
    result = parse("A*02:934")
    assert result.__class__ is Allele, f'Expected parse("A*02:934") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:934") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_935():
    result = parse("A*02:935")
    assert result.__class__ is Allele, f'Expected parse("A*02:935") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:935") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_936N():
    result = parse("A*02:936N")
    assert result.__class__ is Allele, f'Expected parse("A*02:936N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:936N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_937():
    result = parse("A*02:937")
    assert result.__class__ is Allele, f'Expected parse("A*02:937") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:937") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_938():
    result = parse("A*02:938")
    assert result.__class__ is Allele, f'Expected parse("A*02:938") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:938") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_939():
    result = parse("A*02:939")
    assert result.__class__ is Allele, f'Expected parse("A*02:939") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:939") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_93_01():
    result = parse("A*02:93:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:93:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:93:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_93_02():
    result = parse("A*02:93:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:93:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:93:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_94N():
    result = parse("A*02:94N")
    assert result.__class__ is Allele, f'Expected parse("A*02:94N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:94N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_95():
    result = parse("A*02:95")
    assert result.__class__ is Allele, f'Expected parse("A*02:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_96():
    result = parse("A*02:96")
    assert result.__class__ is Allele, f'Expected parse("A*02:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*02:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_97_01():
    result = parse("A*02:97:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:97:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:97:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_97_02():
    result = parse("A*02:97:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:97:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:97:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_99_01():
    result = parse("A*02:99:01")
    assert result.__class__ is Allele, f'Expected parse("A*02:99:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:99:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_02_99_02():
    result = parse("A*02:99:02")
    assert result.__class__ is Allele, f'Expected parse("A*02:99:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*02:99:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_01():
    result = parse("A*03:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_02N():
    result = parse("A*03:01:01:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:02N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_03():
    result = parse("A*03:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_04():
    result = parse("A*03:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_05():
    result = parse("A*03:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_06():
    result = parse("A*03:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_07():
    result = parse("A*03:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_08():
    result = parse("A*03:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_09():
    result = parse("A*03:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_10():
    result = parse("A*03:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_11():
    result = parse("A*03:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_12():
    result = parse("A*03:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_13():
    result = parse("A*03:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_14():
    result = parse("A*03:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_15():
    result = parse("A*03:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_16():
    result = parse("A*03:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_17():
    result = parse("A*03:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_18():
    result = parse("A*03:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_19():
    result = parse("A*03:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_20():
    result = parse("A*03:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_21():
    result = parse("A*03:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_22():
    result = parse("A*03:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_23():
    result = parse("A*03:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_24():
    result = parse("A*03:01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_25():
    result = parse("A*03:01:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_26():
    result = parse("A*03:01:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_27():
    result = parse("A*03:01:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_28():
    result = parse("A*03:01:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_29():
    result = parse("A*03:01:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_30():
    result = parse("A*03:01:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_31():
    result = parse("A*03:01:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_32():
    result = parse("A*03:01:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_33():
    result = parse("A*03:01:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_34():
    result = parse("A*03:01:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_35():
    result = parse("A*03:01:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_36():
    result = parse("A*03:01:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_37():
    result = parse("A*03:01:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_38():
    result = parse("A*03:01:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_39():
    result = parse("A*03:01:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_40():
    result = parse("A*03:01:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_41():
    result = parse("A*03:01:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_42():
    result = parse("A*03:01:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_43():
    result = parse("A*03:01:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_44():
    result = parse("A*03:01:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_45():
    result = parse("A*03:01:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:45") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_46():
    result = parse("A*03:01:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:46") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_47():
    result = parse("A*03:01:01:47")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:47") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_48():
    result = parse("A*03:01:01:48")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:48") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:48") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_49():
    result = parse("A*03:01:01:49")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:49") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:49") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_50():
    result = parse("A*03:01:01:50")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:50") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:50") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_51():
    result = parse("A*03:01:01:51")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:51") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:51") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_52():
    result = parse("A*03:01:01:52")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:52") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:52") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_53():
    result = parse("A*03:01:01:53")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:53") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:53") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_54():
    result = parse("A*03:01:01:54")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:54") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:54") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_55():
    result = parse("A*03:01:01:55")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:55") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:55") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_01_56():
    result = parse("A*03:01:01:56")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:01:56") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:01:56") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_02():
    result = parse("A*03:01:02")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_03():
    result = parse("A*03:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_04():
    result = parse("A*03:01:04")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_05():
    result = parse("A*03:01:05")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_06():
    result = parse("A*03:01:06")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_07():
    result = parse("A*03:01:07")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_08():
    result = parse("A*03:01:08")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_09():
    result = parse("A*03:01:09")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_10():
    result = parse("A*03:01:10")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_11():
    result = parse("A*03:01:11")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_12():
    result = parse("A*03:01:12")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_13():
    result = parse("A*03:01:13")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_14():
    result = parse("A*03:01:14")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_15():
    result = parse("A*03:01:15")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_16():
    result = parse("A*03:01:16")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_17():
    result = parse("A*03:01:17")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_18():
    result = parse("A*03:01:18")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_19():
    result = parse("A*03:01:19")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_20():
    result = parse("A*03:01:20")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_21():
    result = parse("A*03:01:21")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_22():
    result = parse("A*03:01:22")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_23():
    result = parse("A*03:01:23")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_24():
    result = parse("A*03:01:24")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_25():
    result = parse("A*03:01:25")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_26():
    result = parse("A*03:01:26")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_27():
    result = parse("A*03:01:27")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_28():
    result = parse("A*03:01:28")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_29():
    result = parse("A*03:01:29")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_30():
    result = parse("A*03:01:30")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_31():
    result = parse("A*03:01:31")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_32():
    result = parse("A*03:01:32")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_33():
    result = parse("A*03:01:33")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_34():
    result = parse("A*03:01:34")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_35():
    result = parse("A*03:01:35")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_36():
    result = parse("A*03:01:36")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_37():
    result = parse("A*03:01:37")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_38():
    result = parse("A*03:01:38")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_39():
    result = parse("A*03:01:39")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_40():
    result = parse("A*03:01:40")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_41():
    result = parse("A*03:01:41")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_42():
    result = parse("A*03:01:42")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_43():
    result = parse("A*03:01:43")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_44():
    result = parse("A*03:01:44")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_45():
    result = parse("A*03:01:45")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_46():
    result = parse("A*03:01:46")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_47():
    result = parse("A*03:01:47")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_48():
    result = parse("A*03:01:48")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_49():
    result = parse("A*03:01:49")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_50():
    result = parse("A*03:01:50")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_51():
    result = parse("A*03:01:51")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_52():
    result = parse("A*03:01:52")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_53():
    result = parse("A*03:01:53")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_54():
    result = parse("A*03:01:54")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_55():
    result = parse("A*03:01:55")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_56():
    result = parse("A*03:01:56")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_57():
    result = parse("A*03:01:57")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_58():
    result = parse("A*03:01:58")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_59():
    result = parse("A*03:01:59")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_60():
    result = parse("A*03:01:60")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_61():
    result = parse("A*03:01:61")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_62():
    result = parse("A*03:01:62")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_63():
    result = parse("A*03:01:63")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_64():
    result = parse("A*03:01:64")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_65():
    result = parse("A*03:01:65")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_66():
    result = parse("A*03:01:66")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:66") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:66") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_67():
    result = parse("A*03:01:67")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:67") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:67") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_68():
    result = parse("A*03:01:68")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:68") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:68") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_69():
    result = parse("A*03:01:69")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:69") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:69") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_70():
    result = parse("A*03:01:70")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:70") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:70") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_71():
    result = parse("A*03:01:71")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:71") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:71") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_72():
    result = parse("A*03:01:72")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:72") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:72") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_73():
    result = parse("A*03:01:73")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:73") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:73") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_74():
    result = parse("A*03:01:74")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:74") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:74") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_75():
    result = parse("A*03:01:75")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:75") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:75") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_76():
    result = parse("A*03:01:76")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:76") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:76") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_77():
    result = parse("A*03:01:77")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:77") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:77") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_78():
    result = parse("A*03:01:78")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:78") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:78") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_79_01():
    result = parse("A*03:01:79:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:79:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:79:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_79_02():
    result = parse("A*03:01:79:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:01:79:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:01:79:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_80():
    result = parse("A*03:01:80")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:80") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:80") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_81():
    result = parse("A*03:01:81")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:81") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:81") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_82():
    result = parse("A*03:01:82")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:82") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:82") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_83():
    result = parse("A*03:01:83")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:83") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:83") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_84():
    result = parse("A*03:01:84")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:84") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:84") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_85():
    result = parse("A*03:01:85")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:85") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:85") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_86():
    result = parse("A*03:01:86")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:86") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:86") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_87():
    result = parse("A*03:01:87")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:87") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:87") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_88():
    result = parse("A*03:01:88")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:88") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:88") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_89():
    result = parse("A*03:01:89")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:89") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:89") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_90():
    result = parse("A*03:01:90")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:90") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:90") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_91():
    result = parse("A*03:01:91")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:91") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:91") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_92():
    result = parse("A*03:01:92")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:92") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:92") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_01_93():
    result = parse("A*03:01:93")
    assert result.__class__ is Allele, f'Expected parse("A*03:01:93") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:01:93") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_02_01():
    result = parse("A*03:02:01")
    assert result.__class__ is Allele, f'Expected parse("A*03:02:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_02_02():
    result = parse("A*03:02:02")
    assert result.__class__ is Allele, f'Expected parse("A*03:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_02_03():
    result = parse("A*03:02:03")
    assert result.__class__ is Allele, f'Expected parse("A*03:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_02_04():
    result = parse("A*03:02:04")
    assert result.__class__ is Allele, f'Expected parse("A*03:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_03N():
    result = parse("A*03:03N")
    assert result.__class__ is Allele, f'Expected parse("A*03:03N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:03N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_04_01():
    result = parse("A*03:04:01")
    assert result.__class__ is Allele, f'Expected parse("A*03:04:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_04_02():
    result = parse("A*03:04:02")
    assert result.__class__ is Allele, f'Expected parse("A*03:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_04_03():
    result = parse("A*03:04:03")
    assert result.__class__ is Allele, f'Expected parse("A*03:04:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_05_01():
    result = parse("A*03:05:01")
    assert result.__class__ is Allele, f'Expected parse("A*03:05:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_05_02():
    result = parse("A*03:05:02")
    assert result.__class__ is Allele, f'Expected parse("A*03:05:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_06():
    result = parse("A*03:06")
    assert result.__class__ is Allele, f'Expected parse("A*03:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_07_01_01():
    result = parse("A*03:07:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:07:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:07:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_07_01_02():
    result = parse("A*03:07:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:07:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:07:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_07_02():
    result = parse("A*03:07:02")
    assert result.__class__ is Allele, f'Expected parse("A*03:07:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_08_01_01():
    result = parse("A*03:08:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:08:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:08:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_08_01_02():
    result = parse("A*03:08:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:08:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:08:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_09():
    result = parse("A*03:09")
    assert result.__class__ is Allele, f'Expected parse("A*03:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_10():
    result = parse("A*03:10")
    assert result.__class__ is Allele, f'Expected parse("A*03:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_100():
    result = parse("A*03:100")
    assert result.__class__ is Allele, f'Expected parse("A*03:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_101():
    result = parse("A*03:101")
    assert result.__class__ is Allele, f'Expected parse("A*03:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_102():
    result = parse("A*03:102")
    assert result.__class__ is Allele, f'Expected parse("A*03:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_103_01():
    result = parse("A*03:103:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:103:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:103:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_103_02():
    result = parse("A*03:103:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:103:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:103:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_104():
    result = parse("A*03:104")
    assert result.__class__ is Allele, f'Expected parse("A*03:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_105():
    result = parse("A*03:105")
    assert result.__class__ is Allele, f'Expected parse("A*03:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_106():
    result = parse("A*03:106")
    assert result.__class__ is Allele, f'Expected parse("A*03:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_107():
    result = parse("A*03:107")
    assert result.__class__ is Allele, f'Expected parse("A*03:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_108():
    result = parse("A*03:108")
    assert result.__class__ is Allele, f'Expected parse("A*03:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_109():
    result = parse("A*03:109")
    assert result.__class__ is Allele, f'Expected parse("A*03:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_110():
    result = parse("A*03:110")
    assert result.__class__ is Allele, f'Expected parse("A*03:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_111():
    result = parse("A*03:111")
    assert result.__class__ is Allele, f'Expected parse("A*03:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_112():
    result = parse("A*03:112")
    assert result.__class__ is Allele, f'Expected parse("A*03:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_113():
    result = parse("A*03:113")
    assert result.__class__ is Allele, f'Expected parse("A*03:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_114():
    result = parse("A*03:114")
    assert result.__class__ is Allele, f'Expected parse("A*03:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_115():
    result = parse("A*03:115")
    assert result.__class__ is Allele, f'Expected parse("A*03:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_116():
    result = parse("A*03:116")
    assert result.__class__ is Allele, f'Expected parse("A*03:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_117():
    result = parse("A*03:117")
    assert result.__class__ is Allele, f'Expected parse("A*03:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_118():
    result = parse("A*03:118")
    assert result.__class__ is Allele, f'Expected parse("A*03:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_119():
    result = parse("A*03:119")
    assert result.__class__ is Allele, f'Expected parse("A*03:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_11N():
    result = parse("A*03:11N")
    assert result.__class__ is Allele, f'Expected parse("A*03:11N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:11N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_12():
    result = parse("A*03:12")
    assert result.__class__ is Allele, f'Expected parse("A*03:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_120():
    result = parse("A*03:120")
    assert result.__class__ is Allele, f'Expected parse("A*03:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_121():
    result = parse("A*03:121")
    assert result.__class__ is Allele, f'Expected parse("A*03:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_122():
    result = parse("A*03:122")
    assert result.__class__ is Allele, f'Expected parse("A*03:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_123_01():
    result = parse("A*03:123:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:123:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:123:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_123_02():
    result = parse("A*03:123:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:123:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:123:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_124():
    result = parse("A*03:124")
    assert result.__class__ is Allele, f'Expected parse("A*03:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_125():
    result = parse("A*03:125")
    assert result.__class__ is Allele, f'Expected parse("A*03:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_126():
    result = parse("A*03:126")
    assert result.__class__ is Allele, f'Expected parse("A*03:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_127():
    result = parse("A*03:127")
    assert result.__class__ is Allele, f'Expected parse("A*03:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_128():
    result = parse("A*03:128")
    assert result.__class__ is Allele, f'Expected parse("A*03:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_129N():
    result = parse("A*03:129N")
    assert result.__class__ is Allele, f'Expected parse("A*03:129N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:129N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_13():
    result = parse("A*03:13")
    assert result.__class__ is Allele, f'Expected parse("A*03:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_130():
    result = parse("A*03:130")
    assert result.__class__ is Allele, f'Expected parse("A*03:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_131():
    result = parse("A*03:131")
    assert result.__class__ is Allele, f'Expected parse("A*03:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_132():
    result = parse("A*03:132")
    assert result.__class__ is Allele, f'Expected parse("A*03:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_133():
    result = parse("A*03:133")
    assert result.__class__ is Allele, f'Expected parse("A*03:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_134():
    result = parse("A*03:134")
    assert result.__class__ is Allele, f'Expected parse("A*03:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_135():
    result = parse("A*03:135")
    assert result.__class__ is Allele, f'Expected parse("A*03:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_136():
    result = parse("A*03:136")
    assert result.__class__ is Allele, f'Expected parse("A*03:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_137():
    result = parse("A*03:137")
    assert result.__class__ is Allele, f'Expected parse("A*03:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_138():
    result = parse("A*03:138")
    assert result.__class__ is Allele, f'Expected parse("A*03:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_139():
    result = parse("A*03:139")
    assert result.__class__ is Allele, f'Expected parse("A*03:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_14():
    result = parse("A*03:14")
    assert result.__class__ is Allele, f'Expected parse("A*03:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_140():
    result = parse("A*03:140")
    assert result.__class__ is Allele, f'Expected parse("A*03:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_141():
    result = parse("A*03:141")
    assert result.__class__ is Allele, f'Expected parse("A*03:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_142():
    result = parse("A*03:142")
    assert result.__class__ is Allele, f'Expected parse("A*03:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_143():
    result = parse("A*03:143")
    assert result.__class__ is Allele, f'Expected parse("A*03:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_144():
    result = parse("A*03:144")
    assert result.__class__ is Allele, f'Expected parse("A*03:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_145_01():
    result = parse("A*03:145:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:145:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:145:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_145_02():
    result = parse("A*03:145:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:145:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:145:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_146():
    result = parse("A*03:146")
    assert result.__class__ is Allele, f'Expected parse("A*03:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_147():
    result = parse("A*03:147")
    assert result.__class__ is Allele, f'Expected parse("A*03:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_148():
    result = parse("A*03:148")
    assert result.__class__ is Allele, f'Expected parse("A*03:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_149():
    result = parse("A*03:149")
    assert result.__class__ is Allele, f'Expected parse("A*03:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_15():
    result = parse("A*03:15")
    assert result.__class__ is Allele, f'Expected parse("A*03:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_150():
    result = parse("A*03:150")
    assert result.__class__ is Allele, f'Expected parse("A*03:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_151():
    result = parse("A*03:151")
    assert result.__class__ is Allele, f'Expected parse("A*03:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_152():
    result = parse("A*03:152")
    assert result.__class__ is Allele, f'Expected parse("A*03:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_153():
    result = parse("A*03:153")
    assert result.__class__ is Allele, f'Expected parse("A*03:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_154_01():
    result = parse("A*03:154:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:154:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:154:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_154_02():
    result = parse("A*03:154:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:154:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:154:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_155():
    result = parse("A*03:155")
    assert result.__class__ is Allele, f'Expected parse("A*03:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_156():
    result = parse("A*03:156")
    assert result.__class__ is Allele, f'Expected parse("A*03:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_157_01():
    result = parse("A*03:157:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:157:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:157:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_157_02():
    result = parse("A*03:157:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:157:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:157:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_158():
    result = parse("A*03:158")
    assert result.__class__ is Allele, f'Expected parse("A*03:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_159():
    result = parse("A*03:159")
    assert result.__class__ is Allele, f'Expected parse("A*03:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_16():
    result = parse("A*03:16")
    assert result.__class__ is Allele, f'Expected parse("A*03:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_160():
    result = parse("A*03:160")
    assert result.__class__ is Allele, f'Expected parse("A*03:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_161N():
    result = parse("A*03:161N")
    assert result.__class__ is Allele, f'Expected parse("A*03:161N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:161N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_162N():
    result = parse("A*03:162N")
    assert result.__class__ is Allele, f'Expected parse("A*03:162N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:162N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_163():
    result = parse("A*03:163")
    assert result.__class__ is Allele, f'Expected parse("A*03:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_164():
    result = parse("A*03:164")
    assert result.__class__ is Allele, f'Expected parse("A*03:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_165():
    result = parse("A*03:165")
    assert result.__class__ is Allele, f'Expected parse("A*03:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_166():
    result = parse("A*03:166")
    assert result.__class__ is Allele, f'Expected parse("A*03:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_167():
    result = parse("A*03:167")
    assert result.__class__ is Allele, f'Expected parse("A*03:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_168N():
    result = parse("A*03:168N")
    assert result.__class__ is Allele, f'Expected parse("A*03:168N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:168N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_169():
    result = parse("A*03:169")
    assert result.__class__ is Allele, f'Expected parse("A*03:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_170():
    result = parse("A*03:170")
    assert result.__class__ is Allele, f'Expected parse("A*03:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_171():
    result = parse("A*03:171")
    assert result.__class__ is Allele, f'Expected parse("A*03:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_172():
    result = parse("A*03:172")
    assert result.__class__ is Allele, f'Expected parse("A*03:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_173():
    result = parse("A*03:173")
    assert result.__class__ is Allele, f'Expected parse("A*03:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_174():
    result = parse("A*03:174")
    assert result.__class__ is Allele, f'Expected parse("A*03:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_175():
    result = parse("A*03:175")
    assert result.__class__ is Allele, f'Expected parse("A*03:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_176():
    result = parse("A*03:176")
    assert result.__class__ is Allele, f'Expected parse("A*03:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_177():
    result = parse("A*03:177")
    assert result.__class__ is Allele, f'Expected parse("A*03:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_178N():
    result = parse("A*03:178N")
    assert result.__class__ is Allele, f'Expected parse("A*03:178N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:178N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_179():
    result = parse("A*03:179")
    assert result.__class__ is Allele, f'Expected parse("A*03:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_17_01():
    result = parse("A*03:17:01")
    assert result.__class__ is Allele, f'Expected parse("A*03:17:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:17:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_17_02():
    result = parse("A*03:17:02")
    assert result.__class__ is Allele, f'Expected parse("A*03:17:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:17:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_18():
    result = parse("A*03:18")
    assert result.__class__ is Allele, f'Expected parse("A*03:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_180():
    result = parse("A*03:180")
    assert result.__class__ is Allele, f'Expected parse("A*03:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_181():
    result = parse("A*03:181")
    assert result.__class__ is Allele, f'Expected parse("A*03:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_182():
    result = parse("A*03:182")
    assert result.__class__ is Allele, f'Expected parse("A*03:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_183():
    result = parse("A*03:183")
    assert result.__class__ is Allele, f'Expected parse("A*03:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_184():
    result = parse("A*03:184")
    assert result.__class__ is Allele, f'Expected parse("A*03:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_185():
    result = parse("A*03:185")
    assert result.__class__ is Allele, f'Expected parse("A*03:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_186():
    result = parse("A*03:186")
    assert result.__class__ is Allele, f'Expected parse("A*03:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_187():
    result = parse("A*03:187")
    assert result.__class__ is Allele, f'Expected parse("A*03:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_188():
    result = parse("A*03:188")
    assert result.__class__ is Allele, f'Expected parse("A*03:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_189():
    result = parse("A*03:189")
    assert result.__class__ is Allele, f'Expected parse("A*03:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_19():
    result = parse("A*03:19")
    assert result.__class__ is Allele, f'Expected parse("A*03:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_190():
    result = parse("A*03:190")
    assert result.__class__ is Allele, f'Expected parse("A*03:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_191():
    result = parse("A*03:191")
    assert result.__class__ is Allele, f'Expected parse("A*03:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_192N():
    result = parse("A*03:192N")
    assert result.__class__ is Allele, f'Expected parse("A*03:192N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:192N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_193():
    result = parse("A*03:193")
    assert result.__class__ is Allele, f'Expected parse("A*03:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_195():
    result = parse("A*03:195")
    assert result.__class__ is Allele, f'Expected parse("A*03:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_196():
    result = parse("A*03:196")
    assert result.__class__ is Allele, f'Expected parse("A*03:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_197_01N():
    result = parse("A*03:197:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:197:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:197:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_197_02N():
    result = parse("A*03:197:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:197:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:197:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_198():
    result = parse("A*03:198")
    assert result.__class__ is Allele, f'Expected parse("A*03:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_199():
    result = parse("A*03:199")
    assert result.__class__ is Allele, f'Expected parse("A*03:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_20():
    result = parse("A*03:20")
    assert result.__class__ is Allele, f'Expected parse("A*03:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_201():
    result = parse("A*03:201")
    assert result.__class__ is Allele, f'Expected parse("A*03:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_202():
    result = parse("A*03:202")
    assert result.__class__ is Allele, f'Expected parse("A*03:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_203():
    result = parse("A*03:203")
    assert result.__class__ is Allele, f'Expected parse("A*03:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_204():
    result = parse("A*03:204")
    assert result.__class__ is Allele, f'Expected parse("A*03:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_205():
    result = parse("A*03:205")
    assert result.__class__ is Allele, f'Expected parse("A*03:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_206():
    result = parse("A*03:206")
    assert result.__class__ is Allele, f'Expected parse("A*03:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_207():
    result = parse("A*03:207")
    assert result.__class__ is Allele, f'Expected parse("A*03:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_208():
    result = parse("A*03:208")
    assert result.__class__ is Allele, f'Expected parse("A*03:208") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_209():
    result = parse("A*03:209")
    assert result.__class__ is Allele, f'Expected parse("A*03:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_210():
    result = parse("A*03:210")
    assert result.__class__ is Allele, f'Expected parse("A*03:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_211():
    result = parse("A*03:211")
    assert result.__class__ is Allele, f'Expected parse("A*03:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_212():
    result = parse("A*03:212")
    assert result.__class__ is Allele, f'Expected parse("A*03:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_213():
    result = parse("A*03:213")
    assert result.__class__ is Allele, f'Expected parse("A*03:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_214():
    result = parse("A*03:214")
    assert result.__class__ is Allele, f'Expected parse("A*03:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_215():
    result = parse("A*03:215")
    assert result.__class__ is Allele, f'Expected parse("A*03:215") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_216():
    result = parse("A*03:216")
    assert result.__class__ is Allele, f'Expected parse("A*03:216") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_217():
    result = parse("A*03:217")
    assert result.__class__ is Allele, f'Expected parse("A*03:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_218():
    result = parse("A*03:218")
    assert result.__class__ is Allele, f'Expected parse("A*03:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_219():
    result = parse("A*03:219")
    assert result.__class__ is Allele, f'Expected parse("A*03:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_21N():
    result = parse("A*03:21N")
    assert result.__class__ is Allele, f'Expected parse("A*03:21N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:21N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_220():
    result = parse("A*03:220")
    assert result.__class__ is Allele, f'Expected parse("A*03:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_221():
    result = parse("A*03:221")
    assert result.__class__ is Allele, f'Expected parse("A*03:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_222():
    result = parse("A*03:222")
    assert result.__class__ is Allele, f'Expected parse("A*03:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_223():
    result = parse("A*03:223")
    assert result.__class__ is Allele, f'Expected parse("A*03:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_224():
    result = parse("A*03:224")
    assert result.__class__ is Allele, f'Expected parse("A*03:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_225():
    result = parse("A*03:225")
    assert result.__class__ is Allele, f'Expected parse("A*03:225") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_226():
    result = parse("A*03:226")
    assert result.__class__ is Allele, f'Expected parse("A*03:226") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_227():
    result = parse("A*03:227")
    assert result.__class__ is Allele, f'Expected parse("A*03:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_228():
    result = parse("A*03:228")
    assert result.__class__ is Allele, f'Expected parse("A*03:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_229():
    result = parse("A*03:229")
    assert result.__class__ is Allele, f'Expected parse("A*03:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_22_01():
    result = parse("A*03:22:01")
    assert result.__class__ is Allele, f'Expected parse("A*03:22:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:22:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_22_02():
    result = parse("A*03:22:02")
    assert result.__class__ is Allele, f'Expected parse("A*03:22:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:22:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_230():
    result = parse("A*03:230")
    assert result.__class__ is Allele, f'Expected parse("A*03:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_231_01():
    result = parse("A*03:231:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:231:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:231:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_231_02():
    result = parse("A*03:231:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:231:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:231:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_232():
    result = parse("A*03:232")
    assert result.__class__ is Allele, f'Expected parse("A*03:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_233():
    result = parse("A*03:233")
    assert result.__class__ is Allele, f'Expected parse("A*03:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_234Q():
    result = parse("A*03:234Q")
    assert result.__class__ is Allele, f'Expected parse("A*03:234Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:234Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_235():
    result = parse("A*03:235")
    assert result.__class__ is Allele, f'Expected parse("A*03:235") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_236():
    result = parse("A*03:236")
    assert result.__class__ is Allele, f'Expected parse("A*03:236") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_237():
    result = parse("A*03:237")
    assert result.__class__ is Allele, f'Expected parse("A*03:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_238():
    result = parse("A*03:238")
    assert result.__class__ is Allele, f'Expected parse("A*03:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_239():
    result = parse("A*03:239")
    assert result.__class__ is Allele, f'Expected parse("A*03:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_23_01():
    result = parse("A*03:23:01")
    assert result.__class__ is Allele, f'Expected parse("A*03:23:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:23:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_23_02():
    result = parse("A*03:23:02")
    assert result.__class__ is Allele, f'Expected parse("A*03:23:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:23:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_24():
    result = parse("A*03:24")
    assert result.__class__ is Allele, f'Expected parse("A*03:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_240():
    result = parse("A*03:240")
    assert result.__class__ is Allele, f'Expected parse("A*03:240") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_241():
    result = parse("A*03:241")
    assert result.__class__ is Allele, f'Expected parse("A*03:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_242():
    result = parse("A*03:242")
    assert result.__class__ is Allele, f'Expected parse("A*03:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_243():
    result = parse("A*03:243")
    assert result.__class__ is Allele, f'Expected parse("A*03:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_244():
    result = parse("A*03:244")
    assert result.__class__ is Allele, f'Expected parse("A*03:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_245():
    result = parse("A*03:245")
    assert result.__class__ is Allele, f'Expected parse("A*03:245") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_246():
    result = parse("A*03:246")
    assert result.__class__ is Allele, f'Expected parse("A*03:246") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_247():
    result = parse("A*03:247")
    assert result.__class__ is Allele, f'Expected parse("A*03:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_248():
    result = parse("A*03:248")
    assert result.__class__ is Allele, f'Expected parse("A*03:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_249():
    result = parse("A*03:249")
    assert result.__class__ is Allele, f'Expected parse("A*03:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_25():
    result = parse("A*03:25")
    assert result.__class__ is Allele, f'Expected parse("A*03:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_250():
    result = parse("A*03:250")
    assert result.__class__ is Allele, f'Expected parse("A*03:250") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_251():
    result = parse("A*03:251")
    assert result.__class__ is Allele, f'Expected parse("A*03:251") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_252():
    result = parse("A*03:252")
    assert result.__class__ is Allele, f'Expected parse("A*03:252") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_253():
    result = parse("A*03:253")
    assert result.__class__ is Allele, f'Expected parse("A*03:253") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_254():
    result = parse("A*03:254")
    assert result.__class__ is Allele, f'Expected parse("A*03:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_255():
    result = parse("A*03:255")
    assert result.__class__ is Allele, f'Expected parse("A*03:255") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_256():
    result = parse("A*03:256")
    assert result.__class__ is Allele, f'Expected parse("A*03:256") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_257():
    result = parse("A*03:257")
    assert result.__class__ is Allele, f'Expected parse("A*03:257") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_258():
    result = parse("A*03:258")
    assert result.__class__ is Allele, f'Expected parse("A*03:258") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_259():
    result = parse("A*03:259")
    assert result.__class__ is Allele, f'Expected parse("A*03:259") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_26():
    result = parse("A*03:26")
    assert result.__class__ is Allele, f'Expected parse("A*03:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_261():
    result = parse("A*03:261")
    assert result.__class__ is Allele, f'Expected parse("A*03:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_262N():
    result = parse("A*03:262N")
    assert result.__class__ is Allele, f'Expected parse("A*03:262N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:262N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_263():
    result = parse("A*03:263")
    assert result.__class__ is Allele, f'Expected parse("A*03:263") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_264():
    result = parse("A*03:264")
    assert result.__class__ is Allele, f'Expected parse("A*03:264") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_265():
    result = parse("A*03:265")
    assert result.__class__ is Allele, f'Expected parse("A*03:265") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_266N():
    result = parse("A*03:266N")
    assert result.__class__ is Allele, f'Expected parse("A*03:266N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:266N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_267():
    result = parse("A*03:267")
    assert result.__class__ is Allele, f'Expected parse("A*03:267") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_268():
    result = parse("A*03:268")
    assert result.__class__ is Allele, f'Expected parse("A*03:268") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_269N():
    result = parse("A*03:269N")
    assert result.__class__ is Allele, f'Expected parse("A*03:269N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:269N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_27():
    result = parse("A*03:27")
    assert result.__class__ is Allele, f'Expected parse("A*03:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_270():
    result = parse("A*03:270")
    assert result.__class__ is Allele, f'Expected parse("A*03:270") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_271():
    result = parse("A*03:271")
    assert result.__class__ is Allele, f'Expected parse("A*03:271") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_272():
    result = parse("A*03:272")
    assert result.__class__ is Allele, f'Expected parse("A*03:272") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_273():
    result = parse("A*03:273")
    assert result.__class__ is Allele, f'Expected parse("A*03:273") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_274():
    result = parse("A*03:274")
    assert result.__class__ is Allele, f'Expected parse("A*03:274") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_275N():
    result = parse("A*03:275N")
    assert result.__class__ is Allele, f'Expected parse("A*03:275N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:275N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_276():
    result = parse("A*03:276")
    assert result.__class__ is Allele, f'Expected parse("A*03:276") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_277():
    result = parse("A*03:277")
    assert result.__class__ is Allele, f'Expected parse("A*03:277") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_278():
    result = parse("A*03:278")
    assert result.__class__ is Allele, f'Expected parse("A*03:278") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_279N():
    result = parse("A*03:279N")
    assert result.__class__ is Allele, f'Expected parse("A*03:279N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:279N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_28():
    result = parse("A*03:28")
    assert result.__class__ is Allele, f'Expected parse("A*03:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_280_01():
    result = parse("A*03:280:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:280:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:280:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_280_02():
    result = parse("A*03:280:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:280:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:280:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_281():
    result = parse("A*03:281")
    assert result.__class__ is Allele, f'Expected parse("A*03:281") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_282():
    result = parse("A*03:282")
    assert result.__class__ is Allele, f'Expected parse("A*03:282") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_283N():
    result = parse("A*03:283N")
    assert result.__class__ is Allele, f'Expected parse("A*03:283N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:283N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_284N():
    result = parse("A*03:284N")
    assert result.__class__ is Allele, f'Expected parse("A*03:284N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:284N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_285():
    result = parse("A*03:285")
    assert result.__class__ is Allele, f'Expected parse("A*03:285") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_286N():
    result = parse("A*03:286N")
    assert result.__class__ is Allele, f'Expected parse("A*03:286N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:286N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_287():
    result = parse("A*03:287")
    assert result.__class__ is Allele, f'Expected parse("A*03:287") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:287") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_288():
    result = parse("A*03:288")
    assert result.__class__ is Allele, f'Expected parse("A*03:288") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_289_01():
    result = parse("A*03:289:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:289:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:289:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_289_02():
    result = parse("A*03:289:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:289:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:289:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_29():
    result = parse("A*03:29")
    assert result.__class__ is Allele, f'Expected parse("A*03:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_290():
    result = parse("A*03:290")
    assert result.__class__ is Allele, f'Expected parse("A*03:290") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_291():
    result = parse("A*03:291")
    assert result.__class__ is Allele, f'Expected parse("A*03:291") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_292():
    result = parse("A*03:292")
    assert result.__class__ is Allele, f'Expected parse("A*03:292") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_293():
    result = parse("A*03:293")
    assert result.__class__ is Allele, f'Expected parse("A*03:293") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_294():
    result = parse("A*03:294")
    assert result.__class__ is Allele, f'Expected parse("A*03:294") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_295():
    result = parse("A*03:295")
    assert result.__class__ is Allele, f'Expected parse("A*03:295") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_296():
    result = parse("A*03:296")
    assert result.__class__ is Allele, f'Expected parse("A*03:296") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_297N():
    result = parse("A*03:297N")
    assert result.__class__ is Allele, f'Expected parse("A*03:297N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:297N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_298():
    result = parse("A*03:298")
    assert result.__class__ is Allele, f'Expected parse("A*03:298") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_299():
    result = parse("A*03:299")
    assert result.__class__ is Allele, f'Expected parse("A*03:299") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_30():
    result = parse("A*03:30")
    assert result.__class__ is Allele, f'Expected parse("A*03:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_300():
    result = parse("A*03:300")
    assert result.__class__ is Allele, f'Expected parse("A*03:300") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_301():
    result = parse("A*03:301")
    assert result.__class__ is Allele, f'Expected parse("A*03:301") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_302():
    result = parse("A*03:302")
    assert result.__class__ is Allele, f'Expected parse("A*03:302") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_303():
    result = parse("A*03:303")
    assert result.__class__ is Allele, f'Expected parse("A*03:303") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:303") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_304():
    result = parse("A*03:304")
    assert result.__class__ is Allele, f'Expected parse("A*03:304") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:304") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_305():
    result = parse("A*03:305")
    assert result.__class__ is Allele, f'Expected parse("A*03:305") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_306():
    result = parse("A*03:306")
    assert result.__class__ is Allele, f'Expected parse("A*03:306") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:306") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_307():
    result = parse("A*03:307")
    assert result.__class__ is Allele, f'Expected parse("A*03:307") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_308():
    result = parse("A*03:308")
    assert result.__class__ is Allele, f'Expected parse("A*03:308") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:308") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_309():
    result = parse("A*03:309")
    assert result.__class__ is Allele, f'Expected parse("A*03:309") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:309") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_31():
    result = parse("A*03:31")
    assert result.__class__ is Allele, f'Expected parse("A*03:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_310():
    result = parse("A*03:310")
    assert result.__class__ is Allele, f'Expected parse("A*03:310") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:310") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_311():
    result = parse("A*03:311")
    assert result.__class__ is Allele, f'Expected parse("A*03:311") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:311") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_312():
    result = parse("A*03:312")
    assert result.__class__ is Allele, f'Expected parse("A*03:312") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:312") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_313():
    result = parse("A*03:313")
    assert result.__class__ is Allele, f'Expected parse("A*03:313") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:313") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_314():
    result = parse("A*03:314")
    assert result.__class__ is Allele, f'Expected parse("A*03:314") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:314") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_315():
    result = parse("A*03:315")
    assert result.__class__ is Allele, f'Expected parse("A*03:315") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:315") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_316():
    result = parse("A*03:316")
    assert result.__class__ is Allele, f'Expected parse("A*03:316") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:316") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_317():
    result = parse("A*03:317")
    assert result.__class__ is Allele, f'Expected parse("A*03:317") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:317") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_318():
    result = parse("A*03:318")
    assert result.__class__ is Allele, f'Expected parse("A*03:318") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:318") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_319():
    result = parse("A*03:319")
    assert result.__class__ is Allele, f'Expected parse("A*03:319") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_32():
    result = parse("A*03:32")
    assert result.__class__ is Allele, f'Expected parse("A*03:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_320():
    result = parse("A*03:320")
    assert result.__class__ is Allele, f'Expected parse("A*03:320") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:320") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_321():
    result = parse("A*03:321")
    assert result.__class__ is Allele, f'Expected parse("A*03:321") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:321") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_322():
    result = parse("A*03:322")
    assert result.__class__ is Allele, f'Expected parse("A*03:322") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:322") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_323N():
    result = parse("A*03:323N")
    assert result.__class__ is Allele, f'Expected parse("A*03:323N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:323N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_324():
    result = parse("A*03:324")
    assert result.__class__ is Allele, f'Expected parse("A*03:324") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:324") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_325():
    result = parse("A*03:325")
    assert result.__class__ is Allele, f'Expected parse("A*03:325") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:325") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_326():
    result = parse("A*03:326")
    assert result.__class__ is Allele, f'Expected parse("A*03:326") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:326") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_327():
    result = parse("A*03:327")
    assert result.__class__ is Allele, f'Expected parse("A*03:327") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:327") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_328():
    result = parse("A*03:328")
    assert result.__class__ is Allele, f'Expected parse("A*03:328") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:328") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_329N():
    result = parse("A*03:329N")
    assert result.__class__ is Allele, f'Expected parse("A*03:329N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:329N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_33():
    result = parse("A*03:33")
    assert result.__class__ is Allele, f'Expected parse("A*03:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_330N():
    result = parse("A*03:330N")
    assert result.__class__ is Allele, f'Expected parse("A*03:330N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:330N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_331():
    result = parse("A*03:331")
    assert result.__class__ is Allele, f'Expected parse("A*03:331") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:331") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_332():
    result = parse("A*03:332")
    assert result.__class__ is Allele, f'Expected parse("A*03:332") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:332") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_333():
    result = parse("A*03:333")
    assert result.__class__ is Allele, f'Expected parse("A*03:333") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:333") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_334N():
    result = parse("A*03:334N")
    assert result.__class__ is Allele, f'Expected parse("A*03:334N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:334N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_335N():
    result = parse("A*03:335N")
    assert result.__class__ is Allele, f'Expected parse("A*03:335N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:335N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_336N():
    result = parse("A*03:336N")
    assert result.__class__ is Allele, f'Expected parse("A*03:336N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:336N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_337N():
    result = parse("A*03:337N")
    assert result.__class__ is Allele, f'Expected parse("A*03:337N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:337N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_338():
    result = parse("A*03:338")
    assert result.__class__ is Allele, f'Expected parse("A*03:338") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:338") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_339():
    result = parse("A*03:339")
    assert result.__class__ is Allele, f'Expected parse("A*03:339") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:339") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_34():
    result = parse("A*03:34")
    assert result.__class__ is Allele, f'Expected parse("A*03:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_340():
    result = parse("A*03:340")
    assert result.__class__ is Allele, f'Expected parse("A*03:340") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:340") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_341():
    result = parse("A*03:341")
    assert result.__class__ is Allele, f'Expected parse("A*03:341") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:341") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_342N():
    result = parse("A*03:342N")
    assert result.__class__ is Allele, f'Expected parse("A*03:342N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:342N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_343():
    result = parse("A*03:343")
    assert result.__class__ is Allele, f'Expected parse("A*03:343") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:343") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_344():
    result = parse("A*03:344")
    assert result.__class__ is Allele, f'Expected parse("A*03:344") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:344") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_345_01_01():
    result = parse("A*03:345:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:345:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:345:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_345_01_02():
    result = parse("A*03:345:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:345:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:345:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_346():
    result = parse("A*03:346")
    assert result.__class__ is Allele, f'Expected parse("A*03:346") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:346") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_347():
    result = parse("A*03:347")
    assert result.__class__ is Allele, f'Expected parse("A*03:347") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:347") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_348():
    result = parse("A*03:348")
    assert result.__class__ is Allele, f'Expected parse("A*03:348") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:348") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_349():
    result = parse("A*03:349")
    assert result.__class__ is Allele, f'Expected parse("A*03:349") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:349") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_35():
    result = parse("A*03:35")
    assert result.__class__ is Allele, f'Expected parse("A*03:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_350():
    result = parse("A*03:350")
    assert result.__class__ is Allele, f'Expected parse("A*03:350") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:350") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_351():
    result = parse("A*03:351")
    assert result.__class__ is Allele, f'Expected parse("A*03:351") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:351") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_352():
    result = parse("A*03:352")
    assert result.__class__ is Allele, f'Expected parse("A*03:352") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:352") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_353():
    result = parse("A*03:353")
    assert result.__class__ is Allele, f'Expected parse("A*03:353") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:353") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_354():
    result = parse("A*03:354")
    assert result.__class__ is Allele, f'Expected parse("A*03:354") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:354") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_355():
    result = parse("A*03:355")
    assert result.__class__ is Allele, f'Expected parse("A*03:355") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:355") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_356():
    result = parse("A*03:356")
    assert result.__class__ is Allele, f'Expected parse("A*03:356") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:356") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_357N():
    result = parse("A*03:357N")
    assert result.__class__ is Allele, f'Expected parse("A*03:357N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:357N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_358():
    result = parse("A*03:358")
    assert result.__class__ is Allele, f'Expected parse("A*03:358") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:358") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_359():
    result = parse("A*03:359")
    assert result.__class__ is Allele, f'Expected parse("A*03:359") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:359") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_360():
    result = parse("A*03:360")
    assert result.__class__ is Allele, f'Expected parse("A*03:360") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:360") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_361():
    result = parse("A*03:361")
    assert result.__class__ is Allele, f'Expected parse("A*03:361") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:361") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_362():
    result = parse("A*03:362")
    assert result.__class__ is Allele, f'Expected parse("A*03:362") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:362") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_363():
    result = parse("A*03:363")
    assert result.__class__ is Allele, f'Expected parse("A*03:363") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:363") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_364N():
    result = parse("A*03:364N")
    assert result.__class__ is Allele, f'Expected parse("A*03:364N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:364N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_365():
    result = parse("A*03:365")
    assert result.__class__ is Allele, f'Expected parse("A*03:365") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:365") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_366():
    result = parse("A*03:366")
    assert result.__class__ is Allele, f'Expected parse("A*03:366") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:366") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_367():
    result = parse("A*03:367")
    assert result.__class__ is Allele, f'Expected parse("A*03:367") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:367") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_368():
    result = parse("A*03:368")
    assert result.__class__ is Allele, f'Expected parse("A*03:368") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:368") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_369():
    result = parse("A*03:369")
    assert result.__class__ is Allele, f'Expected parse("A*03:369") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:369") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_36N():
    result = parse("A*03:36N")
    assert result.__class__ is Allele, f'Expected parse("A*03:36N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:36N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_37():
    result = parse("A*03:37")
    assert result.__class__ is Allele, f'Expected parse("A*03:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_370():
    result = parse("A*03:370")
    assert result.__class__ is Allele, f'Expected parse("A*03:370") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:370") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_371():
    result = parse("A*03:371")
    assert result.__class__ is Allele, f'Expected parse("A*03:371") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:371") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_372():
    result = parse("A*03:372")
    assert result.__class__ is Allele, f'Expected parse("A*03:372") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:372") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_373():
    result = parse("A*03:373")
    assert result.__class__ is Allele, f'Expected parse("A*03:373") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:373") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_374N():
    result = parse("A*03:374N")
    assert result.__class__ is Allele, f'Expected parse("A*03:374N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:374N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_375():
    result = parse("A*03:375")
    assert result.__class__ is Allele, f'Expected parse("A*03:375") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:375") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_376():
    result = parse("A*03:376")
    assert result.__class__ is Allele, f'Expected parse("A*03:376") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:376") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_377():
    result = parse("A*03:377")
    assert result.__class__ is Allele, f'Expected parse("A*03:377") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:377") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_378():
    result = parse("A*03:378")
    assert result.__class__ is Allele, f'Expected parse("A*03:378") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:378") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_379():
    result = parse("A*03:379")
    assert result.__class__ is Allele, f'Expected parse("A*03:379") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:379") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_38():
    result = parse("A*03:38")
    assert result.__class__ is Allele, f'Expected parse("A*03:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_380():
    result = parse("A*03:380")
    assert result.__class__ is Allele, f'Expected parse("A*03:380") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:380") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_381N():
    result = parse("A*03:381N")
    assert result.__class__ is Allele, f'Expected parse("A*03:381N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:381N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_382():
    result = parse("A*03:382")
    assert result.__class__ is Allele, f'Expected parse("A*03:382") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:382") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_383():
    result = parse("A*03:383")
    assert result.__class__ is Allele, f'Expected parse("A*03:383") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:383") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_384():
    result = parse("A*03:384")
    assert result.__class__ is Allele, f'Expected parse("A*03:384") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:384") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_385():
    result = parse("A*03:385")
    assert result.__class__ is Allele, f'Expected parse("A*03:385") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:385") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_386():
    result = parse("A*03:386")
    assert result.__class__ is Allele, f'Expected parse("A*03:386") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:386") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_387():
    result = parse("A*03:387")
    assert result.__class__ is Allele, f'Expected parse("A*03:387") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:387") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_388Q():
    result = parse("A*03:388Q")
    assert result.__class__ is Allele, f'Expected parse("A*03:388Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:388Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_389():
    result = parse("A*03:389")
    assert result.__class__ is Allele, f'Expected parse("A*03:389") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:389") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_39():
    result = parse("A*03:39")
    assert result.__class__ is Allele, f'Expected parse("A*03:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_390():
    result = parse("A*03:390")
    assert result.__class__ is Allele, f'Expected parse("A*03:390") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:390") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_391():
    result = parse("A*03:391")
    assert result.__class__ is Allele, f'Expected parse("A*03:391") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:391") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_392():
    result = parse("A*03:392")
    assert result.__class__ is Allele, f'Expected parse("A*03:392") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:392") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_393():
    result = parse("A*03:393")
    assert result.__class__ is Allele, f'Expected parse("A*03:393") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:393") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_394():
    result = parse("A*03:394")
    assert result.__class__ is Allele, f'Expected parse("A*03:394") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:394") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_395():
    result = parse("A*03:395")
    assert result.__class__ is Allele, f'Expected parse("A*03:395") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:395") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_40():
    result = parse("A*03:40")
    assert result.__class__ is Allele, f'Expected parse("A*03:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_41():
    result = parse("A*03:41")
    assert result.__class__ is Allele, f'Expected parse("A*03:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_42():
    result = parse("A*03:42")
    assert result.__class__ is Allele, f'Expected parse("A*03:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_43():
    result = parse("A*03:43")
    assert result.__class__ is Allele, f'Expected parse("A*03:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_44_01():
    result = parse("A*03:44:01")
    assert result.__class__ is Allele, f'Expected parse("A*03:44:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:44:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_44_02():
    result = parse("A*03:44:02")
    assert result.__class__ is Allele, f'Expected parse("A*03:44:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:44:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_45():
    result = parse("A*03:45")
    assert result.__class__ is Allele, f'Expected parse("A*03:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_46():
    result = parse("A*03:46")
    assert result.__class__ is Allele, f'Expected parse("A*03:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_47():
    result = parse("A*03:47")
    assert result.__class__ is Allele, f'Expected parse("A*03:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_48():
    result = parse("A*03:48")
    assert result.__class__ is Allele, f'Expected parse("A*03:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_49():
    result = parse("A*03:49")
    assert result.__class__ is Allele, f'Expected parse("A*03:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_50():
    result = parse("A*03:50")
    assert result.__class__ is Allele, f'Expected parse("A*03:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_51_01():
    result = parse("A*03:51:01")
    assert result.__class__ is Allele, f'Expected parse("A*03:51:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:51:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_51_02():
    result = parse("A*03:51:02")
    assert result.__class__ is Allele, f'Expected parse("A*03:51:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:51:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_52():
    result = parse("A*03:52")
    assert result.__class__ is Allele, f'Expected parse("A*03:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_53():
    result = parse("A*03:53")
    assert result.__class__ is Allele, f'Expected parse("A*03:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_54():
    result = parse("A*03:54")
    assert result.__class__ is Allele, f'Expected parse("A*03:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_55():
    result = parse("A*03:55")
    assert result.__class__ is Allele, f'Expected parse("A*03:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_56():
    result = parse("A*03:56")
    assert result.__class__ is Allele, f'Expected parse("A*03:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_57():
    result = parse("A*03:57")
    assert result.__class__ is Allele, f'Expected parse("A*03:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_58():
    result = parse("A*03:58")
    assert result.__class__ is Allele, f'Expected parse("A*03:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_59():
    result = parse("A*03:59")
    assert result.__class__ is Allele, f'Expected parse("A*03:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_60():
    result = parse("A*03:60")
    assert result.__class__ is Allele, f'Expected parse("A*03:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_61():
    result = parse("A*03:61")
    assert result.__class__ is Allele, f'Expected parse("A*03:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_62_01_01():
    result = parse("A*03:62:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:62:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:62:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_62_01_02():
    result = parse("A*03:62:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*03:62:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*03:62:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_63():
    result = parse("A*03:63")
    assert result.__class__ is Allele, f'Expected parse("A*03:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_64():
    result = parse("A*03:64")
    assert result.__class__ is Allele, f'Expected parse("A*03:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_65():
    result = parse("A*03:65")
    assert result.__class__ is Allele, f'Expected parse("A*03:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_66():
    result = parse("A*03:66")
    assert result.__class__ is Allele, f'Expected parse("A*03:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_67():
    result = parse("A*03:67")
    assert result.__class__ is Allele, f'Expected parse("A*03:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_68N():
    result = parse("A*03:68N")
    assert result.__class__ is Allele, f'Expected parse("A*03:68N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:68N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_69N():
    result = parse("A*03:69N")
    assert result.__class__ is Allele, f'Expected parse("A*03:69N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:69N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_70():
    result = parse("A*03:70")
    assert result.__class__ is Allele, f'Expected parse("A*03:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_71():
    result = parse("A*03:71")
    assert result.__class__ is Allele, f'Expected parse("A*03:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_72():
    result = parse("A*03:72")
    assert result.__class__ is Allele, f'Expected parse("A*03:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_73():
    result = parse("A*03:73")
    assert result.__class__ is Allele, f'Expected parse("A*03:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_74():
    result = parse("A*03:74")
    assert result.__class__ is Allele, f'Expected parse("A*03:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_75():
    result = parse("A*03:75")
    assert result.__class__ is Allele, f'Expected parse("A*03:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_76():
    result = parse("A*03:76")
    assert result.__class__ is Allele, f'Expected parse("A*03:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_77():
    result = parse("A*03:77")
    assert result.__class__ is Allele, f'Expected parse("A*03:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_78():
    result = parse("A*03:78")
    assert result.__class__ is Allele, f'Expected parse("A*03:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_79():
    result = parse("A*03:79")
    assert result.__class__ is Allele, f'Expected parse("A*03:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_80():
    result = parse("A*03:80")
    assert result.__class__ is Allele, f'Expected parse("A*03:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_81():
    result = parse("A*03:81")
    assert result.__class__ is Allele, f'Expected parse("A*03:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_82():
    result = parse("A*03:82")
    assert result.__class__ is Allele, f'Expected parse("A*03:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_83():
    result = parse("A*03:83")
    assert result.__class__ is Allele, f'Expected parse("A*03:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_84():
    result = parse("A*03:84")
    assert result.__class__ is Allele, f'Expected parse("A*03:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_85():
    result = parse("A*03:85")
    assert result.__class__ is Allele, f'Expected parse("A*03:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_86():
    result = parse("A*03:86")
    assert result.__class__ is Allele, f'Expected parse("A*03:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_87():
    result = parse("A*03:87")
    assert result.__class__ is Allele, f'Expected parse("A*03:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_88():
    result = parse("A*03:88")
    assert result.__class__ is Allele, f'Expected parse("A*03:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_89_01():
    result = parse("A*03:89:01")
    assert result.__class__ is Allele, f'Expected parse("A*03:89:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:89:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_89_02():
    result = parse("A*03:89:02")
    assert result.__class__ is Allele, f'Expected parse("A*03:89:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*03:89:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_90():
    result = parse("A*03:90")
    assert result.__class__ is Allele, f'Expected parse("A*03:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_91N():
    result = parse("A*03:91N")
    assert result.__class__ is Allele, f'Expected parse("A*03:91N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:91N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_92():
    result = parse("A*03:92")
    assert result.__class__ is Allele, f'Expected parse("A*03:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_93():
    result = parse("A*03:93")
    assert result.__class__ is Allele, f'Expected parse("A*03:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_94():
    result = parse("A*03:94")
    assert result.__class__ is Allele, f'Expected parse("A*03:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_95():
    result = parse("A*03:95")
    assert result.__class__ is Allele, f'Expected parse("A*03:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_96():
    result = parse("A*03:96")
    assert result.__class__ is Allele, f'Expected parse("A*03:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_97():
    result = parse("A*03:97")
    assert result.__class__ is Allele, f'Expected parse("A*03:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_98():
    result = parse("A*03:98")
    assert result.__class__ is Allele, f'Expected parse("A*03:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_03_99():
    result = parse("A*03:99")
    assert result.__class__ is Allele, f'Expected parse("A*03:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*03:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_01():
    result = parse("A*11:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_02():
    result = parse("A*11:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_03():
    result = parse("A*11:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_04():
    result = parse("A*11:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_05():
    result = parse("A*11:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_06():
    result = parse("A*11:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_07():
    result = parse("A*11:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_08():
    result = parse("A*11:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_09():
    result = parse("A*11:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_10():
    result = parse("A*11:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_11():
    result = parse("A*11:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_12():
    result = parse("A*11:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_13():
    result = parse("A*11:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_14():
    result = parse("A*11:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_15():
    result = parse("A*11:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_16():
    result = parse("A*11:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_17():
    result = parse("A*11:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_18():
    result = parse("A*11:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_19():
    result = parse("A*11:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_20():
    result = parse("A*11:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_21():
    result = parse("A*11:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_22():
    result = parse("A*11:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_23():
    result = parse("A*11:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_24():
    result = parse("A*11:01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_25():
    result = parse("A*11:01:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_26():
    result = parse("A*11:01:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_27():
    result = parse("A*11:01:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_28():
    result = parse("A*11:01:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_29():
    result = parse("A*11:01:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_30():
    result = parse("A*11:01:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_31():
    result = parse("A*11:01:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_32():
    result = parse("A*11:01:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_33():
    result = parse("A*11:01:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_34():
    result = parse("A*11:01:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_35():
    result = parse("A*11:01:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_36():
    result = parse("A*11:01:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_37():
    result = parse("A*11:01:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_38():
    result = parse("A*11:01:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_39():
    result = parse("A*11:01:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_40():
    result = parse("A*11:01:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_41():
    result = parse("A*11:01:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_42():
    result = parse("A*11:01:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_43():
    result = parse("A*11:01:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_44():
    result = parse("A*11:01:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_45():
    result = parse("A*11:01:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:45") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_46():
    result = parse("A*11:01:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:46") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_47():
    result = parse("A*11:01:01:47")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:47") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_48():
    result = parse("A*11:01:01:48")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:48") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:48") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_49():
    result = parse("A*11:01:01:49")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:49") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:49") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_01_50():
    result = parse("A*11:01:01:50")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:01:50") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:01:01:50") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_02():
    result = parse("A*11:01:02")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_03():
    result = parse("A*11:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_04():
    result = parse("A*11:01:04")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_05():
    result = parse("A*11:01:05")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_06():
    result = parse("A*11:01:06")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_07():
    result = parse("A*11:01:07")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_08():
    result = parse("A*11:01:08")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_09():
    result = parse("A*11:01:09")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_10():
    result = parse("A*11:01:10")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_100():
    result = parse("A*11:01:100")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:100") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_101():
    result = parse("A*11:01:101")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:101") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_102():
    result = parse("A*11:01:102")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:102") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_103():
    result = parse("A*11:01:103")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:103") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_104():
    result = parse("A*11:01:104")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:104") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_105():
    result = parse("A*11:01:105")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:01:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:105") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_11():
    result = parse("A*11:01:11")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_12():
    result = parse("A*11:01:12")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_13():
    result = parse("A*11:01:13")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_14():
    result = parse("A*11:01:14")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_15():
    result = parse("A*11:01:15")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_16():
    result = parse("A*11:01:16")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_17():
    result = parse("A*11:01:17")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_18():
    result = parse("A*11:01:18")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_19():
    result = parse("A*11:01:19")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_20():
    result = parse("A*11:01:20")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_21():
    result = parse("A*11:01:21")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_22():
    result = parse("A*11:01:22")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_23():
    result = parse("A*11:01:23")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_24():
    result = parse("A*11:01:24")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_25():
    result = parse("A*11:01:25")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_26():
    result = parse("A*11:01:26")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_27():
    result = parse("A*11:01:27")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_28():
    result = parse("A*11:01:28")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_29():
    result = parse("A*11:01:29")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_30():
    result = parse("A*11:01:30")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_31():
    result = parse("A*11:01:31")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_32():
    result = parse("A*11:01:32")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_33():
    result = parse("A*11:01:33")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_34():
    result = parse("A*11:01:34")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_35():
    result = parse("A*11:01:35")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_36():
    result = parse("A*11:01:36")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_37():
    result = parse("A*11:01:37")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_38():
    result = parse("A*11:01:38")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_39():
    result = parse("A*11:01:39")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_40():
    result = parse("A*11:01:40")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_41():
    result = parse("A*11:01:41")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_42():
    result = parse("A*11:01:42")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_43():
    result = parse("A*11:01:43")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_44():
    result = parse("A*11:01:44")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_45():
    result = parse("A*11:01:45")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_46():
    result = parse("A*11:01:46")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_47():
    result = parse("A*11:01:47")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_48():
    result = parse("A*11:01:48")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_49():
    result = parse("A*11:01:49")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_50():
    result = parse("A*11:01:50")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_51():
    result = parse("A*11:01:51")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_52():
    result = parse("A*11:01:52")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_53():
    result = parse("A*11:01:53")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_54():
    result = parse("A*11:01:54")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_55():
    result = parse("A*11:01:55")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_56():
    result = parse("A*11:01:56")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_57():
    result = parse("A*11:01:57")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_58():
    result = parse("A*11:01:58")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_59():
    result = parse("A*11:01:59")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_60():
    result = parse("A*11:01:60")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_61():
    result = parse("A*11:01:61")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_62():
    result = parse("A*11:01:62")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_63():
    result = parse("A*11:01:63")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_64():
    result = parse("A*11:01:64")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_65():
    result = parse("A*11:01:65")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_66():
    result = parse("A*11:01:66")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:66") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:66") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_67():
    result = parse("A*11:01:67")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:67") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:67") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_68():
    result = parse("A*11:01:68")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:68") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:68") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_69():
    result = parse("A*11:01:69")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:69") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:69") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_70():
    result = parse("A*11:01:70")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:70") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:70") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_71():
    result = parse("A*11:01:71")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:71") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:71") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_72():
    result = parse("A*11:01:72")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:72") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:72") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_73():
    result = parse("A*11:01:73")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:73") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:73") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_74():
    result = parse("A*11:01:74")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:74") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:74") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_75():
    result = parse("A*11:01:75")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:75") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:75") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_76():
    result = parse("A*11:01:76")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:76") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:76") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_77():
    result = parse("A*11:01:77")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:77") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:77") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_78():
    result = parse("A*11:01:78")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:78") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:78") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_79():
    result = parse("A*11:01:79")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:79") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:79") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_80():
    result = parse("A*11:01:80")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:80") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:80") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_81():
    result = parse("A*11:01:81")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:81") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:81") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_82():
    result = parse("A*11:01:82")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:82") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:82") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_83():
    result = parse("A*11:01:83")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:83") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:83") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_84():
    result = parse("A*11:01:84")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:84") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:84") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_85():
    result = parse("A*11:01:85")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:85") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:85") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_86():
    result = parse("A*11:01:86")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:86") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:86") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_87():
    result = parse("A*11:01:87")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:87") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:87") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_88():
    result = parse("A*11:01:88")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:88") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:88") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_89():
    result = parse("A*11:01:89")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:89") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:89") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_90():
    result = parse("A*11:01:90")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:90") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:90") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_91():
    result = parse("A*11:01:91")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:91") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:91") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_92():
    result = parse("A*11:01:92")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:92") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:92") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_93():
    result = parse("A*11:01:93")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:93") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:93") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_94():
    result = parse("A*11:01:94")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:94") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:94") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_95():
    result = parse("A*11:01:95")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:95") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:95") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_96():
    result = parse("A*11:01:96")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:96") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:96") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_97():
    result = parse("A*11:01:97")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:97") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:97") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_98():
    result = parse("A*11:01:98")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:98") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:98") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_01_99():
    result = parse("A*11:01:99")
    assert result.__class__ is Allele, f'Expected parse("A*11:01:99") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:01:99") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_02_01_01():
    result = parse("A*11:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_02_01_02():
    result = parse("A*11:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_02_02():
    result = parse("A*11:02:02")
    assert result.__class__ is Allele, f'Expected parse("A*11:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_02_03():
    result = parse("A*11:02:03")
    assert result.__class__ is Allele, f'Expected parse("A*11:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_02_04():
    result = parse("A*11:02:04")
    assert result.__class__ is Allele, f'Expected parse("A*11:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_02_05():
    result = parse("A*11:02:05")
    assert result.__class__ is Allele, f'Expected parse("A*11:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_02_06():
    result = parse("A*11:02:06")
    assert result.__class__ is Allele, f'Expected parse("A*11:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_03():
    result = parse("A*11:03")
    assert result.__class__ is Allele, f'Expected parse("A*11:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_04():
    result = parse("A*11:04")
    assert result.__class__ is Allele, f'Expected parse("A*11:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_05():
    result = parse("A*11:05")
    assert result.__class__ is Allele, f'Expected parse("A*11:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_06():
    result = parse("A*11:06")
    assert result.__class__ is Allele, f'Expected parse("A*11:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_07():
    result = parse("A*11:07")
    assert result.__class__ is Allele, f'Expected parse("A*11:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_08():
    result = parse("A*11:08")
    assert result.__class__ is Allele, f'Expected parse("A*11:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_09():
    result = parse("A*11:09")
    assert result.__class__ is Allele, f'Expected parse("A*11:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_10():
    result = parse("A*11:10")
    assert result.__class__ is Allele, f'Expected parse("A*11:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_100():
    result = parse("A*11:100")
    assert result.__class__ is Allele, f'Expected parse("A*11:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_101():
    result = parse("A*11:101")
    assert result.__class__ is Allele, f'Expected parse("A*11:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_102():
    result = parse("A*11:102")
    assert result.__class__ is Allele, f'Expected parse("A*11:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_103():
    result = parse("A*11:103")
    assert result.__class__ is Allele, f'Expected parse("A*11:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_104():
    result = parse("A*11:104")
    assert result.__class__ is Allele, f'Expected parse("A*11:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_105():
    result = parse("A*11:105")
    assert result.__class__ is Allele, f'Expected parse("A*11:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_106():
    result = parse("A*11:106")
    assert result.__class__ is Allele, f'Expected parse("A*11:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_107():
    result = parse("A*11:107")
    assert result.__class__ is Allele, f'Expected parse("A*11:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_108():
    result = parse("A*11:108")
    assert result.__class__ is Allele, f'Expected parse("A*11:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_109N():
    result = parse("A*11:109N")
    assert result.__class__ is Allele, f'Expected parse("A*11:109N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:109N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_11():
    result = parse("A*11:11")
    assert result.__class__ is Allele, f'Expected parse("A*11:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_110():
    result = parse("A*11:110")
    assert result.__class__ is Allele, f'Expected parse("A*11:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_111():
    result = parse("A*11:111")
    assert result.__class__ is Allele, f'Expected parse("A*11:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_112():
    result = parse("A*11:112")
    assert result.__class__ is Allele, f'Expected parse("A*11:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_113():
    result = parse("A*11:113")
    assert result.__class__ is Allele, f'Expected parse("A*11:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_114():
    result = parse("A*11:114")
    assert result.__class__ is Allele, f'Expected parse("A*11:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_115N():
    result = parse("A*11:115N")
    assert result.__class__ is Allele, f'Expected parse("A*11:115N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:115N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_116():
    result = parse("A*11:116")
    assert result.__class__ is Allele, f'Expected parse("A*11:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_117():
    result = parse("A*11:117")
    assert result.__class__ is Allele, f'Expected parse("A*11:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_118():
    result = parse("A*11:118")
    assert result.__class__ is Allele, f'Expected parse("A*11:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_119_01():
    result = parse("A*11:119:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:119:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:119:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_119_02():
    result = parse("A*11:119:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:119:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:119:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_120():
    result = parse("A*11:120")
    assert result.__class__ is Allele, f'Expected parse("A*11:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_121():
    result = parse("A*11:121")
    assert result.__class__ is Allele, f'Expected parse("A*11:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_122():
    result = parse("A*11:122")
    assert result.__class__ is Allele, f'Expected parse("A*11:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_123():
    result = parse("A*11:123")
    assert result.__class__ is Allele, f'Expected parse("A*11:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_124():
    result = parse("A*11:124")
    assert result.__class__ is Allele, f'Expected parse("A*11:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_125():
    result = parse("A*11:125")
    assert result.__class__ is Allele, f'Expected parse("A*11:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_126_01_01():
    result = parse("A*11:126:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:126:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:126:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_126_01_02():
    result = parse("A*11:126:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:126:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*11:126:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_127N():
    result = parse("A*11:127N")
    assert result.__class__ is Allele, f'Expected parse("A*11:127N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:127N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_128():
    result = parse("A*11:128")
    assert result.__class__ is Allele, f'Expected parse("A*11:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_129():
    result = parse("A*11:129")
    assert result.__class__ is Allele, f'Expected parse("A*11:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_12_01():
    result = parse("A*11:12:01")
    assert result.__class__ is Allele, f'Expected parse("A*11:12:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:12:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_12_02():
    result = parse("A*11:12:02")
    assert result.__class__ is Allele, f'Expected parse("A*11:12:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:12:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_13():
    result = parse("A*11:13")
    assert result.__class__ is Allele, f'Expected parse("A*11:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_130():
    result = parse("A*11:130")
    assert result.__class__ is Allele, f'Expected parse("A*11:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_131():
    result = parse("A*11:131")
    assert result.__class__ is Allele, f'Expected parse("A*11:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_132():
    result = parse("A*11:132")
    assert result.__class__ is Allele, f'Expected parse("A*11:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_133():
    result = parse("A*11:133")
    assert result.__class__ is Allele, f'Expected parse("A*11:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_134():
    result = parse("A*11:134")
    assert result.__class__ is Allele, f'Expected parse("A*11:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_135():
    result = parse("A*11:135")
    assert result.__class__ is Allele, f'Expected parse("A*11:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_136():
    result = parse("A*11:136")
    assert result.__class__ is Allele, f'Expected parse("A*11:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_137_01N():
    result = parse("A*11:137:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:137:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:137:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_137_02N():
    result = parse("A*11:137:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:137:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:137:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_138():
    result = parse("A*11:138")
    assert result.__class__ is Allele, f'Expected parse("A*11:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_139():
    result = parse("A*11:139")
    assert result.__class__ is Allele, f'Expected parse("A*11:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_14():
    result = parse("A*11:14")
    assert result.__class__ is Allele, f'Expected parse("A*11:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_140():
    result = parse("A*11:140")
    assert result.__class__ is Allele, f'Expected parse("A*11:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_141():
    result = parse("A*11:141")
    assert result.__class__ is Allele, f'Expected parse("A*11:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_142():
    result = parse("A*11:142")
    assert result.__class__ is Allele, f'Expected parse("A*11:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_143():
    result = parse("A*11:143")
    assert result.__class__ is Allele, f'Expected parse("A*11:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_144():
    result = parse("A*11:144")
    assert result.__class__ is Allele, f'Expected parse("A*11:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_145():
    result = parse("A*11:145")
    assert result.__class__ is Allele, f'Expected parse("A*11:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_146():
    result = parse("A*11:146")
    assert result.__class__ is Allele, f'Expected parse("A*11:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_147():
    result = parse("A*11:147")
    assert result.__class__ is Allele, f'Expected parse("A*11:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_148():
    result = parse("A*11:148")
    assert result.__class__ is Allele, f'Expected parse("A*11:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_149():
    result = parse("A*11:149")
    assert result.__class__ is Allele, f'Expected parse("A*11:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_150():
    result = parse("A*11:150")
    assert result.__class__ is Allele, f'Expected parse("A*11:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_151():
    result = parse("A*11:151")
    assert result.__class__ is Allele, f'Expected parse("A*11:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_152():
    result = parse("A*11:152")
    assert result.__class__ is Allele, f'Expected parse("A*11:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_153_01():
    result = parse("A*11:153:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:153:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:153:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_153_02():
    result = parse("A*11:153:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:153:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:153:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_154():
    result = parse("A*11:154")
    assert result.__class__ is Allele, f'Expected parse("A*11:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_155():
    result = parse("A*11:155")
    assert result.__class__ is Allele, f'Expected parse("A*11:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_156():
    result = parse("A*11:156")
    assert result.__class__ is Allele, f'Expected parse("A*11:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_157():
    result = parse("A*11:157")
    assert result.__class__ is Allele, f'Expected parse("A*11:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_158():
    result = parse("A*11:158")
    assert result.__class__ is Allele, f'Expected parse("A*11:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_159():
    result = parse("A*11:159")
    assert result.__class__ is Allele, f'Expected parse("A*11:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_15_01():
    result = parse("A*11:15:01")
    assert result.__class__ is Allele, f'Expected parse("A*11:15:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:15:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_15_02():
    result = parse("A*11:15:02")
    assert result.__class__ is Allele, f'Expected parse("A*11:15:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:15:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_16():
    result = parse("A*11:16")
    assert result.__class__ is Allele, f'Expected parse("A*11:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_160():
    result = parse("A*11:160")
    assert result.__class__ is Allele, f'Expected parse("A*11:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_161():
    result = parse("A*11:161")
    assert result.__class__ is Allele, f'Expected parse("A*11:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_162():
    result = parse("A*11:162")
    assert result.__class__ is Allele, f'Expected parse("A*11:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_163():
    result = parse("A*11:163")
    assert result.__class__ is Allele, f'Expected parse("A*11:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_164():
    result = parse("A*11:164")
    assert result.__class__ is Allele, f'Expected parse("A*11:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_165():
    result = parse("A*11:165")
    assert result.__class__ is Allele, f'Expected parse("A*11:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_166():
    result = parse("A*11:166")
    assert result.__class__ is Allele, f'Expected parse("A*11:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_167():
    result = parse("A*11:167")
    assert result.__class__ is Allele, f'Expected parse("A*11:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_168():
    result = parse("A*11:168")
    assert result.__class__ is Allele, f'Expected parse("A*11:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_169():
    result = parse("A*11:169")
    assert result.__class__ is Allele, f'Expected parse("A*11:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_17():
    result = parse("A*11:17")
    assert result.__class__ is Allele, f'Expected parse("A*11:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_170Q():
    result = parse("A*11:170Q")
    assert result.__class__ is Allele, f'Expected parse("A*11:170Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:170Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_171():
    result = parse("A*11:171")
    assert result.__class__ is Allele, f'Expected parse("A*11:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_172():
    result = parse("A*11:172")
    assert result.__class__ is Allele, f'Expected parse("A*11:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_173():
    result = parse("A*11:173")
    assert result.__class__ is Allele, f'Expected parse("A*11:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_174():
    result = parse("A*11:174")
    assert result.__class__ is Allele, f'Expected parse("A*11:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_175():
    result = parse("A*11:175")
    assert result.__class__ is Allele, f'Expected parse("A*11:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_176():
    result = parse("A*11:176")
    assert result.__class__ is Allele, f'Expected parse("A*11:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_177():
    result = parse("A*11:177")
    assert result.__class__ is Allele, f'Expected parse("A*11:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_178():
    result = parse("A*11:178")
    assert result.__class__ is Allele, f'Expected parse("A*11:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_179():
    result = parse("A*11:179")
    assert result.__class__ is Allele, f'Expected parse("A*11:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_18():
    result = parse("A*11:18")
    assert result.__class__ is Allele, f'Expected parse("A*11:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_180N():
    result = parse("A*11:180N")
    assert result.__class__ is Allele, f'Expected parse("A*11:180N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:180N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_181():
    result = parse("A*11:181")
    assert result.__class__ is Allele, f'Expected parse("A*11:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_182Q():
    result = parse("A*11:182Q")
    assert result.__class__ is Allele, f'Expected parse("A*11:182Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:182Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_183():
    result = parse("A*11:183")
    assert result.__class__ is Allele, f'Expected parse("A*11:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_184():
    result = parse("A*11:184")
    assert result.__class__ is Allele, f'Expected parse("A*11:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_185():
    result = parse("A*11:185")
    assert result.__class__ is Allele, f'Expected parse("A*11:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_186():
    result = parse("A*11:186")
    assert result.__class__ is Allele, f'Expected parse("A*11:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_187():
    result = parse("A*11:187")
    assert result.__class__ is Allele, f'Expected parse("A*11:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_188():
    result = parse("A*11:188")
    assert result.__class__ is Allele, f'Expected parse("A*11:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_189():
    result = parse("A*11:189")
    assert result.__class__ is Allele, f'Expected parse("A*11:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_19():
    result = parse("A*11:19")
    assert result.__class__ is Allele, f'Expected parse("A*11:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_190():
    result = parse("A*11:190")
    assert result.__class__ is Allele, f'Expected parse("A*11:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_191():
    result = parse("A*11:191")
    assert result.__class__ is Allele, f'Expected parse("A*11:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_192():
    result = parse("A*11:192")
    assert result.__class__ is Allele, f'Expected parse("A*11:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_193():
    result = parse("A*11:193")
    assert result.__class__ is Allele, f'Expected parse("A*11:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_194():
    result = parse("A*11:194")
    assert result.__class__ is Allele, f'Expected parse("A*11:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_195():
    result = parse("A*11:195")
    assert result.__class__ is Allele, f'Expected parse("A*11:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_196():
    result = parse("A*11:196")
    assert result.__class__ is Allele, f'Expected parse("A*11:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_197():
    result = parse("A*11:197")
    assert result.__class__ is Allele, f'Expected parse("A*11:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_198():
    result = parse("A*11:198")
    assert result.__class__ is Allele, f'Expected parse("A*11:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_199_01():
    result = parse("A*11:199:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:199:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:199:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_199_02():
    result = parse("A*11:199:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:199:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:199:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_199_03():
    result = parse("A*11:199:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:199:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:199:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_20():
    result = parse("A*11:20")
    assert result.__class__ is Allele, f'Expected parse("A*11:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_200():
    result = parse("A*11:200")
    assert result.__class__ is Allele, f'Expected parse("A*11:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_201():
    result = parse("A*11:201")
    assert result.__class__ is Allele, f'Expected parse("A*11:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_202():
    result = parse("A*11:202")
    assert result.__class__ is Allele, f'Expected parse("A*11:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_203():
    result = parse("A*11:203")
    assert result.__class__ is Allele, f'Expected parse("A*11:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_204():
    result = parse("A*11:204")
    assert result.__class__ is Allele, f'Expected parse("A*11:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_205():
    result = parse("A*11:205")
    assert result.__class__ is Allele, f'Expected parse("A*11:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_206():
    result = parse("A*11:206")
    assert result.__class__ is Allele, f'Expected parse("A*11:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_207():
    result = parse("A*11:207")
    assert result.__class__ is Allele, f'Expected parse("A*11:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_208N():
    result = parse("A*11:208N")
    assert result.__class__ is Allele, f'Expected parse("A*11:208N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:208N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_209():
    result = parse("A*11:209")
    assert result.__class__ is Allele, f'Expected parse("A*11:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_210N():
    result = parse("A*11:210N")
    assert result.__class__ is Allele, f'Expected parse("A*11:210N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:210N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_211():
    result = parse("A*11:211")
    assert result.__class__ is Allele, f'Expected parse("A*11:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_212():
    result = parse("A*11:212")
    assert result.__class__ is Allele, f'Expected parse("A*11:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_213():
    result = parse("A*11:213")
    assert result.__class__ is Allele, f'Expected parse("A*11:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_214():
    result = parse("A*11:214")
    assert result.__class__ is Allele, f'Expected parse("A*11:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_215N():
    result = parse("A*11:215N")
    assert result.__class__ is Allele, f'Expected parse("A*11:215N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:215N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_216():
    result = parse("A*11:216")
    assert result.__class__ is Allele, f'Expected parse("A*11:216") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_217():
    result = parse("A*11:217")
    assert result.__class__ is Allele, f'Expected parse("A*11:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_218():
    result = parse("A*11:218")
    assert result.__class__ is Allele, f'Expected parse("A*11:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_219():
    result = parse("A*11:219")
    assert result.__class__ is Allele, f'Expected parse("A*11:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_21N():
    result = parse("A*11:21N")
    assert result.__class__ is Allele, f'Expected parse("A*11:21N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:21N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_22():
    result = parse("A*11:22")
    assert result.__class__ is Allele, f'Expected parse("A*11:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_220():
    result = parse("A*11:220")
    assert result.__class__ is Allele, f'Expected parse("A*11:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_221():
    result = parse("A*11:221")
    assert result.__class__ is Allele, f'Expected parse("A*11:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_222():
    result = parse("A*11:222")
    assert result.__class__ is Allele, f'Expected parse("A*11:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_223():
    result = parse("A*11:223")
    assert result.__class__ is Allele, f'Expected parse("A*11:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_224():
    result = parse("A*11:224")
    assert result.__class__ is Allele, f'Expected parse("A*11:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_225():
    result = parse("A*11:225")
    assert result.__class__ is Allele, f'Expected parse("A*11:225") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_226():
    result = parse("A*11:226")
    assert result.__class__ is Allele, f'Expected parse("A*11:226") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_227():
    result = parse("A*11:227")
    assert result.__class__ is Allele, f'Expected parse("A*11:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_228():
    result = parse("A*11:228")
    assert result.__class__ is Allele, f'Expected parse("A*11:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_229():
    result = parse("A*11:229")
    assert result.__class__ is Allele, f'Expected parse("A*11:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_23():
    result = parse("A*11:23")
    assert result.__class__ is Allele, f'Expected parse("A*11:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_230():
    result = parse("A*11:230")
    assert result.__class__ is Allele, f'Expected parse("A*11:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_231():
    result = parse("A*11:231")
    assert result.__class__ is Allele, f'Expected parse("A*11:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_232():
    result = parse("A*11:232")
    assert result.__class__ is Allele, f'Expected parse("A*11:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_233():
    result = parse("A*11:233")
    assert result.__class__ is Allele, f'Expected parse("A*11:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_234():
    result = parse("A*11:234")
    assert result.__class__ is Allele, f'Expected parse("A*11:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_235Q():
    result = parse("A*11:235Q")
    assert result.__class__ is Allele, f'Expected parse("A*11:235Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:235Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_236():
    result = parse("A*11:236")
    assert result.__class__ is Allele, f'Expected parse("A*11:236") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_237():
    result = parse("A*11:237")
    assert result.__class__ is Allele, f'Expected parse("A*11:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_238N():
    result = parse("A*11:238N")
    assert result.__class__ is Allele, f'Expected parse("A*11:238N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:238N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_239():
    result = parse("A*11:239")
    assert result.__class__ is Allele, f'Expected parse("A*11:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_240():
    result = parse("A*11:240")
    assert result.__class__ is Allele, f'Expected parse("A*11:240") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_241():
    result = parse("A*11:241")
    assert result.__class__ is Allele, f'Expected parse("A*11:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_242():
    result = parse("A*11:242")
    assert result.__class__ is Allele, f'Expected parse("A*11:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_243():
    result = parse("A*11:243")
    assert result.__class__ is Allele, f'Expected parse("A*11:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_244():
    result = parse("A*11:244")
    assert result.__class__ is Allele, f'Expected parse("A*11:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_245():
    result = parse("A*11:245")
    assert result.__class__ is Allele, f'Expected parse("A*11:245") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_246():
    result = parse("A*11:246")
    assert result.__class__ is Allele, f'Expected parse("A*11:246") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_247():
    result = parse("A*11:247")
    assert result.__class__ is Allele, f'Expected parse("A*11:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_248():
    result = parse("A*11:248")
    assert result.__class__ is Allele, f'Expected parse("A*11:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_249():
    result = parse("A*11:249")
    assert result.__class__ is Allele, f'Expected parse("A*11:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_24_01():
    result = parse("A*11:24:01")
    assert result.__class__ is Allele, f'Expected parse("A*11:24:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:24:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_24_02():
    result = parse("A*11:24:02")
    assert result.__class__ is Allele, f'Expected parse("A*11:24:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:24:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_250():
    result = parse("A*11:250")
    assert result.__class__ is Allele, f'Expected parse("A*11:250") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_251N():
    result = parse("A*11:251N")
    assert result.__class__ is Allele, f'Expected parse("A*11:251N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:251N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_252():
    result = parse("A*11:252")
    assert result.__class__ is Allele, f'Expected parse("A*11:252") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_253():
    result = parse("A*11:253")
    assert result.__class__ is Allele, f'Expected parse("A*11:253") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_254():
    result = parse("A*11:254")
    assert result.__class__ is Allele, f'Expected parse("A*11:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_255():
    result = parse("A*11:255")
    assert result.__class__ is Allele, f'Expected parse("A*11:255") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_256Q():
    result = parse("A*11:256Q")
    assert result.__class__ is Allele, f'Expected parse("A*11:256Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:256Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_257():
    result = parse("A*11:257")
    assert result.__class__ is Allele, f'Expected parse("A*11:257") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_258():
    result = parse("A*11:258")
    assert result.__class__ is Allele, f'Expected parse("A*11:258") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_259():
    result = parse("A*11:259")
    assert result.__class__ is Allele, f'Expected parse("A*11:259") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_25_01():
    result = parse("A*11:25:01")
    assert result.__class__ is Allele, f'Expected parse("A*11:25:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:25:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_25_02():
    result = parse("A*11:25:02")
    assert result.__class__ is Allele, f'Expected parse("A*11:25:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:25:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_26():
    result = parse("A*11:26")
    assert result.__class__ is Allele, f'Expected parse("A*11:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_260():
    result = parse("A*11:260")
    assert result.__class__ is Allele, f'Expected parse("A*11:260") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_261():
    result = parse("A*11:261")
    assert result.__class__ is Allele, f'Expected parse("A*11:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_262():
    result = parse("A*11:262")
    assert result.__class__ is Allele, f'Expected parse("A*11:262") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_263():
    result = parse("A*11:263")
    assert result.__class__ is Allele, f'Expected parse("A*11:263") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_264():
    result = parse("A*11:264")
    assert result.__class__ is Allele, f'Expected parse("A*11:264") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_265():
    result = parse("A*11:265")
    assert result.__class__ is Allele, f'Expected parse("A*11:265") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_266():
    result = parse("A*11:266")
    assert result.__class__ is Allele, f'Expected parse("A*11:266") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_267():
    result = parse("A*11:267")
    assert result.__class__ is Allele, f'Expected parse("A*11:267") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_268():
    result = parse("A*11:268")
    assert result.__class__ is Allele, f'Expected parse("A*11:268") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_269():
    result = parse("A*11:269")
    assert result.__class__ is Allele, f'Expected parse("A*11:269") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_27():
    result = parse("A*11:27")
    assert result.__class__ is Allele, f'Expected parse("A*11:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_270():
    result = parse("A*11:270")
    assert result.__class__ is Allele, f'Expected parse("A*11:270") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_271():
    result = parse("A*11:271")
    assert result.__class__ is Allele, f'Expected parse("A*11:271") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_272Q():
    result = parse("A*11:272Q")
    assert result.__class__ is Allele, f'Expected parse("A*11:272Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:272Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_273():
    result = parse("A*11:273")
    assert result.__class__ is Allele, f'Expected parse("A*11:273") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_274():
    result = parse("A*11:274")
    assert result.__class__ is Allele, f'Expected parse("A*11:274") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_275():
    result = parse("A*11:275")
    assert result.__class__ is Allele, f'Expected parse("A*11:275") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_276():
    result = parse("A*11:276")
    assert result.__class__ is Allele, f'Expected parse("A*11:276") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_277():
    result = parse("A*11:277")
    assert result.__class__ is Allele, f'Expected parse("A*11:277") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_278():
    result = parse("A*11:278")
    assert result.__class__ is Allele, f'Expected parse("A*11:278") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_279():
    result = parse("A*11:279")
    assert result.__class__ is Allele, f'Expected parse("A*11:279") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_280():
    result = parse("A*11:280")
    assert result.__class__ is Allele, f'Expected parse("A*11:280") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_281():
    result = parse("A*11:281")
    assert result.__class__ is Allele, f'Expected parse("A*11:281") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_282():
    result = parse("A*11:282")
    assert result.__class__ is Allele, f'Expected parse("A*11:282") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_283():
    result = parse("A*11:283")
    assert result.__class__ is Allele, f'Expected parse("A*11:283") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_284():
    result = parse("A*11:284")
    assert result.__class__ is Allele, f'Expected parse("A*11:284") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_285():
    result = parse("A*11:285")
    assert result.__class__ is Allele, f'Expected parse("A*11:285") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_286():
    result = parse("A*11:286")
    assert result.__class__ is Allele, f'Expected parse("A*11:286") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_287N():
    result = parse("A*11:287N")
    assert result.__class__ is Allele, f'Expected parse("A*11:287N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:287N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_288():
    result = parse("A*11:288")
    assert result.__class__ is Allele, f'Expected parse("A*11:288") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_289():
    result = parse("A*11:289")
    assert result.__class__ is Allele, f'Expected parse("A*11:289") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_29():
    result = parse("A*11:29")
    assert result.__class__ is Allele, f'Expected parse("A*11:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_290():
    result = parse("A*11:290")
    assert result.__class__ is Allele, f'Expected parse("A*11:290") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_291():
    result = parse("A*11:291")
    assert result.__class__ is Allele, f'Expected parse("A*11:291") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_292():
    result = parse("A*11:292")
    assert result.__class__ is Allele, f'Expected parse("A*11:292") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_293():
    result = parse("A*11:293")
    assert result.__class__ is Allele, f'Expected parse("A*11:293") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_294():
    result = parse("A*11:294")
    assert result.__class__ is Allele, f'Expected parse("A*11:294") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_295():
    result = parse("A*11:295")
    assert result.__class__ is Allele, f'Expected parse("A*11:295") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_296():
    result = parse("A*11:296")
    assert result.__class__ is Allele, f'Expected parse("A*11:296") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_297():
    result = parse("A*11:297")
    assert result.__class__ is Allele, f'Expected parse("A*11:297") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_298():
    result = parse("A*11:298")
    assert result.__class__ is Allele, f'Expected parse("A*11:298") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_299():
    result = parse("A*11:299")
    assert result.__class__ is Allele, f'Expected parse("A*11:299") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_30():
    result = parse("A*11:30")
    assert result.__class__ is Allele, f'Expected parse("A*11:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_300():
    result = parse("A*11:300")
    assert result.__class__ is Allele, f'Expected parse("A*11:300") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_301():
    result = parse("A*11:301")
    assert result.__class__ is Allele, f'Expected parse("A*11:301") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_302_01():
    result = parse("A*11:302:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:302:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:302:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_302_02():
    result = parse("A*11:302:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:302:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:302:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_303():
    result = parse("A*11:303")
    assert result.__class__ is Allele, f'Expected parse("A*11:303") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:303") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_304():
    result = parse("A*11:304")
    assert result.__class__ is Allele, f'Expected parse("A*11:304") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:304") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_305():
    result = parse("A*11:305")
    assert result.__class__ is Allele, f'Expected parse("A*11:305") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_306():
    result = parse("A*11:306")
    assert result.__class__ is Allele, f'Expected parse("A*11:306") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:306") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_307():
    result = parse("A*11:307")
    assert result.__class__ is Allele, f'Expected parse("A*11:307") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_308():
    result = parse("A*11:308")
    assert result.__class__ is Allele, f'Expected parse("A*11:308") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:308") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_309():
    result = parse("A*11:309")
    assert result.__class__ is Allele, f'Expected parse("A*11:309") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:309") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_31():
    result = parse("A*11:31")
    assert result.__class__ is Allele, f'Expected parse("A*11:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_310N():
    result = parse("A*11:310N")
    assert result.__class__ is Allele, f'Expected parse("A*11:310N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:310N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_311():
    result = parse("A*11:311")
    assert result.__class__ is Allele, f'Expected parse("A*11:311") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:311") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_312():
    result = parse("A*11:312")
    assert result.__class__ is Allele, f'Expected parse("A*11:312") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:312") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_313Q():
    result = parse("A*11:313Q")
    assert result.__class__ is Allele, f'Expected parse("A*11:313Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:313Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_314():
    result = parse("A*11:314")
    assert result.__class__ is Allele, f'Expected parse("A*11:314") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:314") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_315():
    result = parse("A*11:315")
    assert result.__class__ is Allele, f'Expected parse("A*11:315") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:315") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_316():
    result = parse("A*11:316")
    assert result.__class__ is Allele, f'Expected parse("A*11:316") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:316") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_317():
    result = parse("A*11:317")
    assert result.__class__ is Allele, f'Expected parse("A*11:317") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:317") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_318():
    result = parse("A*11:318")
    assert result.__class__ is Allele, f'Expected parse("A*11:318") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:318") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_319():
    result = parse("A*11:319")
    assert result.__class__ is Allele, f'Expected parse("A*11:319") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_320():
    result = parse("A*11:320")
    assert result.__class__ is Allele, f'Expected parse("A*11:320") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:320") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_321():
    result = parse("A*11:321")
    assert result.__class__ is Allele, f'Expected parse("A*11:321") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:321") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_322():
    result = parse("A*11:322")
    assert result.__class__ is Allele, f'Expected parse("A*11:322") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:322") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_323():
    result = parse("A*11:323")
    assert result.__class__ is Allele, f'Expected parse("A*11:323") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:323") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_324():
    result = parse("A*11:324")
    assert result.__class__ is Allele, f'Expected parse("A*11:324") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:324") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_325():
    result = parse("A*11:325")
    assert result.__class__ is Allele, f'Expected parse("A*11:325") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:325") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_326():
    result = parse("A*11:326")
    assert result.__class__ is Allele, f'Expected parse("A*11:326") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:326") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_327():
    result = parse("A*11:327")
    assert result.__class__ is Allele, f'Expected parse("A*11:327") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:327") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_328():
    result = parse("A*11:328")
    assert result.__class__ is Allele, f'Expected parse("A*11:328") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:328") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_329():
    result = parse("A*11:329")
    assert result.__class__ is Allele, f'Expected parse("A*11:329") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:329") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_32_01():
    result = parse("A*11:32:01")
    assert result.__class__ is Allele, f'Expected parse("A*11:32:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:32:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_32_02():
    result = parse("A*11:32:02")
    assert result.__class__ is Allele, f'Expected parse("A*11:32:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:32:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_330():
    result = parse("A*11:330")
    assert result.__class__ is Allele, f'Expected parse("A*11:330") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:330") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_331():
    result = parse("A*11:331")
    assert result.__class__ is Allele, f'Expected parse("A*11:331") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:331") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_332():
    result = parse("A*11:332")
    assert result.__class__ is Allele, f'Expected parse("A*11:332") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:332") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_333():
    result = parse("A*11:333")
    assert result.__class__ is Allele, f'Expected parse("A*11:333") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:333") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_334():
    result = parse("A*11:334")
    assert result.__class__ is Allele, f'Expected parse("A*11:334") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:334") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_335():
    result = parse("A*11:335")
    assert result.__class__ is Allele, f'Expected parse("A*11:335") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:335") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_336():
    result = parse("A*11:336")
    assert result.__class__ is Allele, f'Expected parse("A*11:336") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:336") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_337():
    result = parse("A*11:337")
    assert result.__class__ is Allele, f'Expected parse("A*11:337") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:337") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_338():
    result = parse("A*11:338")
    assert result.__class__ is Allele, f'Expected parse("A*11:338") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:338") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_339():
    result = parse("A*11:339")
    assert result.__class__ is Allele, f'Expected parse("A*11:339") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:339") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_33_01():
    result = parse("A*11:33:01")
    assert result.__class__ is Allele, f'Expected parse("A*11:33:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:33:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_33_02():
    result = parse("A*11:33:02")
    assert result.__class__ is Allele, f'Expected parse("A*11:33:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:33:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_34():
    result = parse("A*11:34")
    assert result.__class__ is Allele, f'Expected parse("A*11:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_340N():
    result = parse("A*11:340N")
    assert result.__class__ is Allele, f'Expected parse("A*11:340N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:340N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_341():
    result = parse("A*11:341")
    assert result.__class__ is Allele, f'Expected parse("A*11:341") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:341") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_342():
    result = parse("A*11:342")
    assert result.__class__ is Allele, f'Expected parse("A*11:342") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:342") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_343():
    result = parse("A*11:343")
    assert result.__class__ is Allele, f'Expected parse("A*11:343") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:343") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_344():
    result = parse("A*11:344")
    assert result.__class__ is Allele, f'Expected parse("A*11:344") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:344") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_345():
    result = parse("A*11:345")
    assert result.__class__ is Allele, f'Expected parse("A*11:345") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:345") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_346():
    result = parse("A*11:346")
    assert result.__class__ is Allele, f'Expected parse("A*11:346") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:346") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_347N():
    result = parse("A*11:347N")
    assert result.__class__ is Allele, f'Expected parse("A*11:347N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:347N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_348():
    result = parse("A*11:348")
    assert result.__class__ is Allele, f'Expected parse("A*11:348") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:348") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_349():
    result = parse("A*11:349")
    assert result.__class__ is Allele, f'Expected parse("A*11:349") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:349") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_35():
    result = parse("A*11:35")
    assert result.__class__ is Allele, f'Expected parse("A*11:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_350():
    result = parse("A*11:350")
    assert result.__class__ is Allele, f'Expected parse("A*11:350") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:350") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_351Q():
    result = parse("A*11:351Q")
    assert result.__class__ is Allele, f'Expected parse("A*11:351Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:351Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_352():
    result = parse("A*11:352")
    assert result.__class__ is Allele, f'Expected parse("A*11:352") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:352") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_353():
    result = parse("A*11:353")
    assert result.__class__ is Allele, f'Expected parse("A*11:353") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:353") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_354():
    result = parse("A*11:354")
    assert result.__class__ is Allele, f'Expected parse("A*11:354") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:354") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_355_01():
    result = parse("A*11:355:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:355:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:355:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_355_02():
    result = parse("A*11:355:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*11:355:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:355:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_356():
    result = parse("A*11:356")
    assert result.__class__ is Allele, f'Expected parse("A*11:356") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:356") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_357():
    result = parse("A*11:357")
    assert result.__class__ is Allele, f'Expected parse("A*11:357") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:357") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_358():
    result = parse("A*11:358")
    assert result.__class__ is Allele, f'Expected parse("A*11:358") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:358") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_359():
    result = parse("A*11:359")
    assert result.__class__ is Allele, f'Expected parse("A*11:359") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:359") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_36():
    result = parse("A*11:36")
    assert result.__class__ is Allele, f'Expected parse("A*11:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_360():
    result = parse("A*11:360")
    assert result.__class__ is Allele, f'Expected parse("A*11:360") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:360") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_361():
    result = parse("A*11:361")
    assert result.__class__ is Allele, f'Expected parse("A*11:361") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:361") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_362():
    result = parse("A*11:362")
    assert result.__class__ is Allele, f'Expected parse("A*11:362") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:362") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_363():
    result = parse("A*11:363")
    assert result.__class__ is Allele, f'Expected parse("A*11:363") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:363") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_364():
    result = parse("A*11:364")
    assert result.__class__ is Allele, f'Expected parse("A*11:364") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:364") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_365N():
    result = parse("A*11:365N")
    assert result.__class__ is Allele, f'Expected parse("A*11:365N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:365N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_366():
    result = parse("A*11:366")
    assert result.__class__ is Allele, f'Expected parse("A*11:366") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:366") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_367():
    result = parse("A*11:367")
    assert result.__class__ is Allele, f'Expected parse("A*11:367") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:367") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_368():
    result = parse("A*11:368")
    assert result.__class__ is Allele, f'Expected parse("A*11:368") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:368") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_369():
    result = parse("A*11:369")
    assert result.__class__ is Allele, f'Expected parse("A*11:369") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:369") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_37():
    result = parse("A*11:37")
    assert result.__class__ is Allele, f'Expected parse("A*11:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_370():
    result = parse("A*11:370")
    assert result.__class__ is Allele, f'Expected parse("A*11:370") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:370") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_371():
    result = parse("A*11:371")
    assert result.__class__ is Allele, f'Expected parse("A*11:371") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:371") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_372():
    result = parse("A*11:372")
    assert result.__class__ is Allele, f'Expected parse("A*11:372") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:372") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_373():
    result = parse("A*11:373")
    assert result.__class__ is Allele, f'Expected parse("A*11:373") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:373") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_374():
    result = parse("A*11:374")
    assert result.__class__ is Allele, f'Expected parse("A*11:374") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:374") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_375Q():
    result = parse("A*11:375Q")
    assert result.__class__ is Allele, f'Expected parse("A*11:375Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:375Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_376():
    result = parse("A*11:376")
    assert result.__class__ is Allele, f'Expected parse("A*11:376") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:376") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_38():
    result = parse("A*11:38")
    assert result.__class__ is Allele, f'Expected parse("A*11:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_39():
    result = parse("A*11:39")
    assert result.__class__ is Allele, f'Expected parse("A*11:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_40():
    result = parse("A*11:40")
    assert result.__class__ is Allele, f'Expected parse("A*11:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_41():
    result = parse("A*11:41")
    assert result.__class__ is Allele, f'Expected parse("A*11:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_42():
    result = parse("A*11:42")
    assert result.__class__ is Allele, f'Expected parse("A*11:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_43():
    result = parse("A*11:43")
    assert result.__class__ is Allele, f'Expected parse("A*11:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_44():
    result = parse("A*11:44")
    assert result.__class__ is Allele, f'Expected parse("A*11:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_45():
    result = parse("A*11:45")
    assert result.__class__ is Allele, f'Expected parse("A*11:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_46():
    result = parse("A*11:46")
    assert result.__class__ is Allele, f'Expected parse("A*11:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_47():
    result = parse("A*11:47")
    assert result.__class__ is Allele, f'Expected parse("A*11:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_48():
    result = parse("A*11:48")
    assert result.__class__ is Allele, f'Expected parse("A*11:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_49():
    result = parse("A*11:49")
    assert result.__class__ is Allele, f'Expected parse("A*11:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_50Q():
    result = parse("A*11:50Q")
    assert result.__class__ is Allele, f'Expected parse("A*11:50Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:50Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_51():
    result = parse("A*11:51")
    assert result.__class__ is Allele, f'Expected parse("A*11:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_52Q():
    result = parse("A*11:52Q")
    assert result.__class__ is Allele, f'Expected parse("A*11:52Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:52Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_54_01():
    result = parse("A*11:54:01")
    assert result.__class__ is Allele, f'Expected parse("A*11:54:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:54:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_54_02():
    result = parse("A*11:54:02")
    assert result.__class__ is Allele, f'Expected parse("A*11:54:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:54:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_55():
    result = parse("A*11:55")
    assert result.__class__ is Allele, f'Expected parse("A*11:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_56():
    result = parse("A*11:56")
    assert result.__class__ is Allele, f'Expected parse("A*11:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_57():
    result = parse("A*11:57")
    assert result.__class__ is Allele, f'Expected parse("A*11:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_58():
    result = parse("A*11:58")
    assert result.__class__ is Allele, f'Expected parse("A*11:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_59():
    result = parse("A*11:59")
    assert result.__class__ is Allele, f'Expected parse("A*11:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_60():
    result = parse("A*11:60")
    assert result.__class__ is Allele, f'Expected parse("A*11:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_61():
    result = parse("A*11:61")
    assert result.__class__ is Allele, f'Expected parse("A*11:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_62():
    result = parse("A*11:62")
    assert result.__class__ is Allele, f'Expected parse("A*11:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_63():
    result = parse("A*11:63")
    assert result.__class__ is Allele, f'Expected parse("A*11:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_64():
    result = parse("A*11:64")
    assert result.__class__ is Allele, f'Expected parse("A*11:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_65():
    result = parse("A*11:65")
    assert result.__class__ is Allele, f'Expected parse("A*11:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_66():
    result = parse("A*11:66")
    assert result.__class__ is Allele, f'Expected parse("A*11:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_67():
    result = parse("A*11:67")
    assert result.__class__ is Allele, f'Expected parse("A*11:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_68():
    result = parse("A*11:68")
    assert result.__class__ is Allele, f'Expected parse("A*11:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_69N():
    result = parse("A*11:69N")
    assert result.__class__ is Allele, f'Expected parse("A*11:69N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:69N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_70_01():
    result = parse("A*11:70:01")
    assert result.__class__ is Allele, f'Expected parse("A*11:70:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:70:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_70_02():
    result = parse("A*11:70:02")
    assert result.__class__ is Allele, f'Expected parse("A*11:70:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:70:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_71():
    result = parse("A*11:71")
    assert result.__class__ is Allele, f'Expected parse("A*11:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_72():
    result = parse("A*11:72")
    assert result.__class__ is Allele, f'Expected parse("A*11:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_73():
    result = parse("A*11:73")
    assert result.__class__ is Allele, f'Expected parse("A*11:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_74():
    result = parse("A*11:74")
    assert result.__class__ is Allele, f'Expected parse("A*11:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_75():
    result = parse("A*11:75")
    assert result.__class__ is Allele, f'Expected parse("A*11:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_76():
    result = parse("A*11:76")
    assert result.__class__ is Allele, f'Expected parse("A*11:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_77():
    result = parse("A*11:77")
    assert result.__class__ is Allele, f'Expected parse("A*11:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_78N():
    result = parse("A*11:78N")
    assert result.__class__ is Allele, f'Expected parse("A*11:78N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:78N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_79():
    result = parse("A*11:79")
    assert result.__class__ is Allele, f'Expected parse("A*11:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_80():
    result = parse("A*11:80")
    assert result.__class__ is Allele, f'Expected parse("A*11:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_81():
    result = parse("A*11:81")
    assert result.__class__ is Allele, f'Expected parse("A*11:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_82():
    result = parse("A*11:82")
    assert result.__class__ is Allele, f'Expected parse("A*11:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_83():
    result = parse("A*11:83")
    assert result.__class__ is Allele, f'Expected parse("A*11:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_84():
    result = parse("A*11:84")
    assert result.__class__ is Allele, f'Expected parse("A*11:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_85():
    result = parse("A*11:85")
    assert result.__class__ is Allele, f'Expected parse("A*11:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_86():
    result = parse("A*11:86")
    assert result.__class__ is Allele, f'Expected parse("A*11:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_87():
    result = parse("A*11:87")
    assert result.__class__ is Allele, f'Expected parse("A*11:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_88():
    result = parse("A*11:88")
    assert result.__class__ is Allele, f'Expected parse("A*11:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_89():
    result = parse("A*11:89")
    assert result.__class__ is Allele, f'Expected parse("A*11:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_90():
    result = parse("A*11:90")
    assert result.__class__ is Allele, f'Expected parse("A*11:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_91_01():
    result = parse("A*11:91:01")
    assert result.__class__ is Allele, f'Expected parse("A*11:91:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:91:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_91_02():
    result = parse("A*11:91:02")
    assert result.__class__ is Allele, f'Expected parse("A*11:91:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*11:91:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_92():
    result = parse("A*11:92")
    assert result.__class__ is Allele, f'Expected parse("A*11:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_93():
    result = parse("A*11:93")
    assert result.__class__ is Allele, f'Expected parse("A*11:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_94():
    result = parse("A*11:94")
    assert result.__class__ is Allele, f'Expected parse("A*11:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_95():
    result = parse("A*11:95")
    assert result.__class__ is Allele, f'Expected parse("A*11:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_96():
    result = parse("A*11:96")
    assert result.__class__ is Allele, f'Expected parse("A*11:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_97():
    result = parse("A*11:97")
    assert result.__class__ is Allele, f'Expected parse("A*11:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_98():
    result = parse("A*11:98")
    assert result.__class__ is Allele, f'Expected parse("A*11:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_11_99N():
    result = parse("A*11:99N")
    assert result.__class__ is Allele, f'Expected parse("A*11:99N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*11:99N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_01():
    result = parse("A*23:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_02():
    result = parse("A*23:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_03():
    result = parse("A*23:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_04():
    result = parse("A*23:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_05():
    result = parse("A*23:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_06():
    result = parse("A*23:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_07():
    result = parse("A*23:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_08():
    result = parse("A*23:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_09():
    result = parse("A*23:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_10():
    result = parse("A*23:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_11():
    result = parse("A*23:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_12():
    result = parse("A*23:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_13():
    result = parse("A*23:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_14():
    result = parse("A*23:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_15():
    result = parse("A*23:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_16():
    result = parse("A*23:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_01_17():
    result = parse("A*23:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_02():
    result = parse("A*23:01:02")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_03():
    result = parse("A*23:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_04():
    result = parse("A*23:01:04")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_05():
    result = parse("A*23:01:05")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_06():
    result = parse("A*23:01:06")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_07():
    result = parse("A*23:01:07")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_08():
    result = parse("A*23:01:08")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_09():
    result = parse("A*23:01:09")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_10():
    result = parse("A*23:01:10")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_11():
    result = parse("A*23:01:11")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_12():
    result = parse("A*23:01:12")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_13():
    result = parse("A*23:01:13")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_14():
    result = parse("A*23:01:14")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_15():
    result = parse("A*23:01:15")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_16():
    result = parse("A*23:01:16")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_17():
    result = parse("A*23:01:17")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_18():
    result = parse("A*23:01:18")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_19():
    result = parse("A*23:01:19")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_20():
    result = parse("A*23:01:20")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_21():
    result = parse("A*23:01:21")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_22():
    result = parse("A*23:01:22")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_23():
    result = parse("A*23:01:23")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_24():
    result = parse("A*23:01:24")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_25():
    result = parse("A*23:01:25")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_26():
    result = parse("A*23:01:26")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_27():
    result = parse("A*23:01:27")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_28():
    result = parse("A*23:01:28")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_29():
    result = parse("A*23:01:29")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_30():
    result = parse("A*23:01:30")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_01_31():
    result = parse("A*23:01:31")
    assert result.__class__ is Allele, f'Expected parse("A*23:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_02():
    result = parse("A*23:02")
    assert result.__class__ is Allele, f'Expected parse("A*23:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_03_01():
    result = parse("A*23:03:01")
    assert result.__class__ is Allele, f'Expected parse("A*23:03:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:03:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_03_02_01():
    result = parse("A*23:03:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:03:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:03:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_03_02_02():
    result = parse("A*23:03:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:03:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:03:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_04():
    result = parse("A*23:04")
    assert result.__class__ is Allele, f'Expected parse("A*23:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_05():
    result = parse("A*23:05")
    assert result.__class__ is Allele, f'Expected parse("A*23:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_06():
    result = parse("A*23:06")
    assert result.__class__ is Allele, f'Expected parse("A*23:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_07N():
    result = parse("A*23:07N")
    assert result.__class__ is Allele, f'Expected parse("A*23:07N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:07N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_08N():
    result = parse("A*23:08N")
    assert result.__class__ is Allele, f'Expected parse("A*23:08N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:08N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_09():
    result = parse("A*23:09")
    assert result.__class__ is Allele, f'Expected parse("A*23:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_10():
    result = parse("A*23:10")
    assert result.__class__ is Allele, f'Expected parse("A*23:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_100():
    result = parse("A*23:100")
    assert result.__class__ is Allele, f'Expected parse("A*23:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_101():
    result = parse("A*23:101")
    assert result.__class__ is Allele, f'Expected parse("A*23:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_102():
    result = parse("A*23:102")
    assert result.__class__ is Allele, f'Expected parse("A*23:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_103N():
    result = parse("A*23:103N")
    assert result.__class__ is Allele, f'Expected parse("A*23:103N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:103N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_104():
    result = parse("A*23:104")
    assert result.__class__ is Allele, f'Expected parse("A*23:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_105():
    result = parse("A*23:105")
    assert result.__class__ is Allele, f'Expected parse("A*23:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_106N():
    result = parse("A*23:106N")
    assert result.__class__ is Allele, f'Expected parse("A*23:106N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:106N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_107Q():
    result = parse("A*23:107Q")
    assert result.__class__ is Allele, f'Expected parse("A*23:107Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:107Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_108N():
    result = parse("A*23:108N")
    assert result.__class__ is Allele, f'Expected parse("A*23:108N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:108N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_11N():
    result = parse("A*23:11N")
    assert result.__class__ is Allele, f'Expected parse("A*23:11N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:11N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_12():
    result = parse("A*23:12")
    assert result.__class__ is Allele, f'Expected parse("A*23:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_13():
    result = parse("A*23:13")
    assert result.__class__ is Allele, f'Expected parse("A*23:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_14_01():
    result = parse("A*23:14:01")
    assert result.__class__ is Allele, f'Expected parse("A*23:14:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:14:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_14_02():
    result = parse("A*23:14:02")
    assert result.__class__ is Allele, f'Expected parse("A*23:14:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:14:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_15():
    result = parse("A*23:15")
    assert result.__class__ is Allele, f'Expected parse("A*23:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_16():
    result = parse("A*23:16")
    assert result.__class__ is Allele, f'Expected parse("A*23:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_17_01_01():
    result = parse("A*23:17:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:17:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:17:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_17_01_02():
    result = parse("A*23:17:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:17:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:17:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_17_01_03():
    result = parse("A*23:17:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*23:17:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*23:17:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_17_02():
    result = parse("A*23:17:02")
    assert result.__class__ is Allele, f'Expected parse("A*23:17:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:17:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_18():
    result = parse("A*23:18")
    assert result.__class__ is Allele, f'Expected parse("A*23:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_19N():
    result = parse("A*23:19N")
    assert result.__class__ is Allele, f'Expected parse("A*23:19N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:19N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_20():
    result = parse("A*23:20")
    assert result.__class__ is Allele, f'Expected parse("A*23:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_21():
    result = parse("A*23:21")
    assert result.__class__ is Allele, f'Expected parse("A*23:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_22():
    result = parse("A*23:22")
    assert result.__class__ is Allele, f'Expected parse("A*23:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_23():
    result = parse("A*23:23")
    assert result.__class__ is Allele, f'Expected parse("A*23:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_24():
    result = parse("A*23:24")
    assert result.__class__ is Allele, f'Expected parse("A*23:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_25():
    result = parse("A*23:25")
    assert result.__class__ is Allele, f'Expected parse("A*23:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_26():
    result = parse("A*23:26")
    assert result.__class__ is Allele, f'Expected parse("A*23:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_27():
    result = parse("A*23:27")
    assert result.__class__ is Allele, f'Expected parse("A*23:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_28():
    result = parse("A*23:28")
    assert result.__class__ is Allele, f'Expected parse("A*23:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_29():
    result = parse("A*23:29")
    assert result.__class__ is Allele, f'Expected parse("A*23:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_30():
    result = parse("A*23:30")
    assert result.__class__ is Allele, f'Expected parse("A*23:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_31():
    result = parse("A*23:31")
    assert result.__class__ is Allele, f'Expected parse("A*23:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_32():
    result = parse("A*23:32")
    assert result.__class__ is Allele, f'Expected parse("A*23:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_33():
    result = parse("A*23:33")
    assert result.__class__ is Allele, f'Expected parse("A*23:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_34():
    result = parse("A*23:34")
    assert result.__class__ is Allele, f'Expected parse("A*23:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_35():
    result = parse("A*23:35")
    assert result.__class__ is Allele, f'Expected parse("A*23:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_36():
    result = parse("A*23:36")
    assert result.__class__ is Allele, f'Expected parse("A*23:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_37_01():
    result = parse("A*23:37:01")
    assert result.__class__ is Allele, f'Expected parse("A*23:37:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:37:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_37_02():
    result = parse("A*23:37:02")
    assert result.__class__ is Allele, f'Expected parse("A*23:37:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*23:37:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_38N():
    result = parse("A*23:38N")
    assert result.__class__ is Allele, f'Expected parse("A*23:38N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:38N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_39():
    result = parse("A*23:39")
    assert result.__class__ is Allele, f'Expected parse("A*23:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_40():
    result = parse("A*23:40")
    assert result.__class__ is Allele, f'Expected parse("A*23:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_41():
    result = parse("A*23:41")
    assert result.__class__ is Allele, f'Expected parse("A*23:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_42():
    result = parse("A*23:42")
    assert result.__class__ is Allele, f'Expected parse("A*23:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_43():
    result = parse("A*23:43")
    assert result.__class__ is Allele, f'Expected parse("A*23:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_44():
    result = parse("A*23:44")
    assert result.__class__ is Allele, f'Expected parse("A*23:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_45():
    result = parse("A*23:45")
    assert result.__class__ is Allele, f'Expected parse("A*23:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_46():
    result = parse("A*23:46")
    assert result.__class__ is Allele, f'Expected parse("A*23:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_47():
    result = parse("A*23:47")
    assert result.__class__ is Allele, f'Expected parse("A*23:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_48():
    result = parse("A*23:48")
    assert result.__class__ is Allele, f'Expected parse("A*23:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_49():
    result = parse("A*23:49")
    assert result.__class__ is Allele, f'Expected parse("A*23:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_50():
    result = parse("A*23:50")
    assert result.__class__ is Allele, f'Expected parse("A*23:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_51():
    result = parse("A*23:51")
    assert result.__class__ is Allele, f'Expected parse("A*23:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_52():
    result = parse("A*23:52")
    assert result.__class__ is Allele, f'Expected parse("A*23:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_53():
    result = parse("A*23:53")
    assert result.__class__ is Allele, f'Expected parse("A*23:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_54():
    result = parse("A*23:54")
    assert result.__class__ is Allele, f'Expected parse("A*23:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_55():
    result = parse("A*23:55")
    assert result.__class__ is Allele, f'Expected parse("A*23:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_56():
    result = parse("A*23:56")
    assert result.__class__ is Allele, f'Expected parse("A*23:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_57():
    result = parse("A*23:57")
    assert result.__class__ is Allele, f'Expected parse("A*23:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_58():
    result = parse("A*23:58")
    assert result.__class__ is Allele, f'Expected parse("A*23:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_59():
    result = parse("A*23:59")
    assert result.__class__ is Allele, f'Expected parse("A*23:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_60():
    result = parse("A*23:60")
    assert result.__class__ is Allele, f'Expected parse("A*23:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_61():
    result = parse("A*23:61")
    assert result.__class__ is Allele, f'Expected parse("A*23:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_62():
    result = parse("A*23:62")
    assert result.__class__ is Allele, f'Expected parse("A*23:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_63():
    result = parse("A*23:63")
    assert result.__class__ is Allele, f'Expected parse("A*23:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_64():
    result = parse("A*23:64")
    assert result.__class__ is Allele, f'Expected parse("A*23:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_65():
    result = parse("A*23:65")
    assert result.__class__ is Allele, f'Expected parse("A*23:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_66():
    result = parse("A*23:66")
    assert result.__class__ is Allele, f'Expected parse("A*23:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_67():
    result = parse("A*23:67")
    assert result.__class__ is Allele, f'Expected parse("A*23:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_68():
    result = parse("A*23:68")
    assert result.__class__ is Allele, f'Expected parse("A*23:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_70():
    result = parse("A*23:70")
    assert result.__class__ is Allele, f'Expected parse("A*23:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_71():
    result = parse("A*23:71")
    assert result.__class__ is Allele, f'Expected parse("A*23:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_72():
    result = parse("A*23:72")
    assert result.__class__ is Allele, f'Expected parse("A*23:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_73():
    result = parse("A*23:73")
    assert result.__class__ is Allele, f'Expected parse("A*23:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_74():
    result = parse("A*23:74")
    assert result.__class__ is Allele, f'Expected parse("A*23:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_75():
    result = parse("A*23:75")
    assert result.__class__ is Allele, f'Expected parse("A*23:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_76():
    result = parse("A*23:76")
    assert result.__class__ is Allele, f'Expected parse("A*23:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_77():
    result = parse("A*23:77")
    assert result.__class__ is Allele, f'Expected parse("A*23:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_78():
    result = parse("A*23:78")
    assert result.__class__ is Allele, f'Expected parse("A*23:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_79():
    result = parse("A*23:79")
    assert result.__class__ is Allele, f'Expected parse("A*23:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_80():
    result = parse("A*23:80")
    assert result.__class__ is Allele, f'Expected parse("A*23:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_81():
    result = parse("A*23:81")
    assert result.__class__ is Allele, f'Expected parse("A*23:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_82():
    result = parse("A*23:82")
    assert result.__class__ is Allele, f'Expected parse("A*23:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_83():
    result = parse("A*23:83")
    assert result.__class__ is Allele, f'Expected parse("A*23:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_84N():
    result = parse("A*23:84N")
    assert result.__class__ is Allele, f'Expected parse("A*23:84N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:84N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_85():
    result = parse("A*23:85")
    assert result.__class__ is Allele, f'Expected parse("A*23:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_86():
    result = parse("A*23:86")
    assert result.__class__ is Allele, f'Expected parse("A*23:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_87():
    result = parse("A*23:87")
    assert result.__class__ is Allele, f'Expected parse("A*23:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_88():
    result = parse("A*23:88")
    assert result.__class__ is Allele, f'Expected parse("A*23:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_89():
    result = parse("A*23:89")
    assert result.__class__ is Allele, f'Expected parse("A*23:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_90():
    result = parse("A*23:90")
    assert result.__class__ is Allele, f'Expected parse("A*23:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_91N():
    result = parse("A*23:91N")
    assert result.__class__ is Allele, f'Expected parse("A*23:91N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:91N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_92():
    result = parse("A*23:92")
    assert result.__class__ is Allele, f'Expected parse("A*23:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_93():
    result = parse("A*23:93")
    assert result.__class__ is Allele, f'Expected parse("A*23:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_94():
    result = parse("A*23:94")
    assert result.__class__ is Allele, f'Expected parse("A*23:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_95():
    result = parse("A*23:95")
    assert result.__class__ is Allele, f'Expected parse("A*23:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_96():
    result = parse("A*23:96")
    assert result.__class__ is Allele, f'Expected parse("A*23:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_97():
    result = parse("A*23:97")
    assert result.__class__ is Allele, f'Expected parse("A*23:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_98():
    result = parse("A*23:98")
    assert result.__class__ is Allele, f'Expected parse("A*23:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_23_99():
    result = parse("A*23:99")
    assert result.__class__ is Allele, f'Expected parse("A*23:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*23:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_01():
    result = parse("A*24:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_02L():
    result = parse("A*24:02:01:02L")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:02L") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:02L") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_03():
    result = parse("A*24:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_04():
    result = parse("A*24:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_05():
    result = parse("A*24:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_06():
    result = parse("A*24:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_07():
    result = parse("A*24:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_08():
    result = parse("A*24:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_09():
    result = parse("A*24:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_10():
    result = parse("A*24:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_11():
    result = parse("A*24:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_12():
    result = parse("A*24:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_13():
    result = parse("A*24:02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_14():
    result = parse("A*24:02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_15():
    result = parse("A*24:02:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_16():
    result = parse("A*24:02:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_17Q():
    result = parse("A*24:02:01:17Q")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:17Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:17Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_18():
    result = parse("A*24:02:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_19():
    result = parse("A*24:02:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_20():
    result = parse("A*24:02:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_21():
    result = parse("A*24:02:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_22():
    result = parse("A*24:02:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_23():
    result = parse("A*24:02:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_24():
    result = parse("A*24:02:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_25():
    result = parse("A*24:02:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_26():
    result = parse("A*24:02:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_27():
    result = parse("A*24:02:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_28():
    result = parse("A*24:02:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_29():
    result = parse("A*24:02:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_30():
    result = parse("A*24:02:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_31():
    result = parse("A*24:02:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_32():
    result = parse("A*24:02:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_33():
    result = parse("A*24:02:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_34():
    result = parse("A*24:02:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_35():
    result = parse("A*24:02:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_36():
    result = parse("A*24:02:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_37():
    result = parse("A*24:02:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_38():
    result = parse("A*24:02:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_39():
    result = parse("A*24:02:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_40():
    result = parse("A*24:02:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_41():
    result = parse("A*24:02:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_42():
    result = parse("A*24:02:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_43():
    result = parse("A*24:02:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_44():
    result = parse("A*24:02:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_45():
    result = parse("A*24:02:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:45") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_46():
    result = parse("A*24:02:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:46") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_47():
    result = parse("A*24:02:01:47")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:47") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_48():
    result = parse("A*24:02:01:48")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:48") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:48") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_49():
    result = parse("A*24:02:01:49")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:49") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:49") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_50():
    result = parse("A*24:02:01:50")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:50") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:50") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_51():
    result = parse("A*24:02:01:51")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:51") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:51") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_52():
    result = parse("A*24:02:01:52")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:52") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:52") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_53():
    result = parse("A*24:02:01:53")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:53") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:53") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_54():
    result = parse("A*24:02:01:54")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:54") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:54") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_55():
    result = parse("A*24:02:01:55")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:55") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:55") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_56():
    result = parse("A*24:02:01:56")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:56") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:56") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_57():
    result = parse("A*24:02:01:57")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:57") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:57") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_58():
    result = parse("A*24:02:01:58")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:58") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:58") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_59():
    result = parse("A*24:02:01:59")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:59") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:59") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_60():
    result = parse("A*24:02:01:60")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:60") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:60") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_61():
    result = parse("A*24:02:01:61")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:61") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:61") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_62():
    result = parse("A*24:02:01:62")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:62") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:62") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_63():
    result = parse("A*24:02:01:63")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:63") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:63") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_64():
    result = parse("A*24:02:01:64")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:64") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:64") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_65():
    result = parse("A*24:02:01:65")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:65") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:65") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_66():
    result = parse("A*24:02:01:66")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:66") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:66") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_67():
    result = parse("A*24:02:01:67")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:67") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:67") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_68():
    result = parse("A*24:02:01:68")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:68") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:68") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_69():
    result = parse("A*24:02:01:69")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:69") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:69") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_70():
    result = parse("A*24:02:01:70")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:70") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:70") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_71():
    result = parse("A*24:02:01:71")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:71") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:71") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_72():
    result = parse("A*24:02:01:72")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:72") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:72") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_73():
    result = parse("A*24:02:01:73")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:73") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:73") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_74():
    result = parse("A*24:02:01:74")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:74") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:74") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_75():
    result = parse("A*24:02:01:75")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:75") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:75") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_76():
    result = parse("A*24:02:01:76")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:76") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:76") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_77():
    result = parse("A*24:02:01:77")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:77") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:77") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_78():
    result = parse("A*24:02:01:78")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:78") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:78") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_79():
    result = parse("A*24:02:01:79")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:79") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:79") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_80():
    result = parse("A*24:02:01:80")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:80") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:80") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_81():
    result = parse("A*24:02:01:81")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:81") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:81") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_82():
    result = parse("A*24:02:01:82")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:82") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:82") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_83():
    result = parse("A*24:02:01:83")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:83") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:83") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_01_84():
    result = parse("A*24:02:01:84")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:01:84") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:01:84") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_02():
    result = parse("A*24:02:02")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_03Q():
    result = parse("A*24:02:03Q")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:03Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:03Q") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_04():
    result = parse("A*24:02:04")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_05():
    result = parse("A*24:02:05")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_06():
    result = parse("A*24:02:06")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_07():
    result = parse("A*24:02:07")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_08():
    result = parse("A*24:02:08")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_09():
    result = parse("A*24:02:09")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_10():
    result = parse("A*24:02:10")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_100():
    result = parse("A*24:02:100")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:100") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_101():
    result = parse("A*24:02:101")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:101") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_102_01():
    result = parse("A*24:02:102:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:102:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:102:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_102_02():
    result = parse("A*24:02:102:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:102:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:102:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_103():
    result = parse("A*24:02:103")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:103") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_104():
    result = parse("A*24:02:104")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:104") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_105():
    result = parse("A*24:02:105")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:105") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_106():
    result = parse("A*24:02:106")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:106") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_107():
    result = parse("A*24:02:107")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:107") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_108():
    result = parse("A*24:02:108")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:108") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_109():
    result = parse("A*24:02:109")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:109") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_11():
    result = parse("A*24:02:11")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_110():
    result = parse("A*24:02:110")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:110") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_111():
    result = parse("A*24:02:111")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:111") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_112():
    result = parse("A*24:02:112")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:112") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_113():
    result = parse("A*24:02:113")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:113") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_114():
    result = parse("A*24:02:114")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:114") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_115_01():
    result = parse("A*24:02:115:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:115:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:115:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_115_02():
    result = parse("A*24:02:115:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:115:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:115:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_116():
    result = parse("A*24:02:116")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:116") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_117():
    result = parse("A*24:02:117")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:117") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_118():
    result = parse("A*24:02:118")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:118") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:118") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_119():
    result = parse("A*24:02:119")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:119") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:119") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_12():
    result = parse("A*24:02:12")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_120():
    result = parse("A*24:02:120")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:120") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:120") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_121():
    result = parse("A*24:02:121")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:121") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:121") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_122():
    result = parse("A*24:02:122")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:122") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:122") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_123():
    result = parse("A*24:02:123")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:123") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:123") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_124():
    result = parse("A*24:02:124")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:124") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:124") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_125():
    result = parse("A*24:02:125")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:125") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:125") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_126():
    result = parse("A*24:02:126")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:126") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:126") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_127():
    result = parse("A*24:02:127")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:127") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:127") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_128():
    result = parse("A*24:02:128")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:128") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:128") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_129():
    result = parse("A*24:02:129")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:129") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:129") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_13():
    result = parse("A*24:02:13")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_130():
    result = parse("A*24:02:130")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:130") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:130") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_131():
    result = parse("A*24:02:131")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:131") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:131") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_132():
    result = parse("A*24:02:132")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:132") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:132") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_133():
    result = parse("A*24:02:133")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:133") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:133") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_134():
    result = parse("A*24:02:134")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:134") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:134") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_135():
    result = parse("A*24:02:135")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:135") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:135") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_136():
    result = parse("A*24:02:136")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:136") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:136") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_137():
    result = parse("A*24:02:137")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:137") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:137") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_138():
    result = parse("A*24:02:138")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:138") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:138") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_139():
    result = parse("A*24:02:139")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:139") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:139") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_14():
    result = parse("A*24:02:14")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_15():
    result = parse("A*24:02:15")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_16():
    result = parse("A*24:02:16")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_17():
    result = parse("A*24:02:17")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_18():
    result = parse("A*24:02:18")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_19():
    result = parse("A*24:02:19")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_20():
    result = parse("A*24:02:20")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_21():
    result = parse("A*24:02:21")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_22():
    result = parse("A*24:02:22")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_23():
    result = parse("A*24:02:23")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_24():
    result = parse("A*24:02:24")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_25():
    result = parse("A*24:02:25")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_26():
    result = parse("A*24:02:26")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_27():
    result = parse("A*24:02:27")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_28():
    result = parse("A*24:02:28")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_29():
    result = parse("A*24:02:29")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_30():
    result = parse("A*24:02:30")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_31():
    result = parse("A*24:02:31")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_32():
    result = parse("A*24:02:32")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_33():
    result = parse("A*24:02:33")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_34():
    result = parse("A*24:02:34")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_35():
    result = parse("A*24:02:35")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_36():
    result = parse("A*24:02:36")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_37():
    result = parse("A*24:02:37")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_38():
    result = parse("A*24:02:38")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_39():
    result = parse("A*24:02:39")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_40_01():
    result = parse("A*24:02:40:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:40:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:40:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_40_02():
    result = parse("A*24:02:40:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:02:40:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:02:40:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_41():
    result = parse("A*24:02:41")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_42():
    result = parse("A*24:02:42")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_43():
    result = parse("A*24:02:43")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_44():
    result = parse("A*24:02:44")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_45():
    result = parse("A*24:02:45")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_46():
    result = parse("A*24:02:46")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_47():
    result = parse("A*24:02:47")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_48():
    result = parse("A*24:02:48")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_49():
    result = parse("A*24:02:49")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_50():
    result = parse("A*24:02:50")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_51():
    result = parse("A*24:02:51")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_52():
    result = parse("A*24:02:52")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_53():
    result = parse("A*24:02:53")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_54():
    result = parse("A*24:02:54")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_55():
    result = parse("A*24:02:55")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_56():
    result = parse("A*24:02:56")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_57():
    result = parse("A*24:02:57")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_58():
    result = parse("A*24:02:58")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_59():
    result = parse("A*24:02:59")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_60():
    result = parse("A*24:02:60")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_61():
    result = parse("A*24:02:61")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_62():
    result = parse("A*24:02:62")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_63():
    result = parse("A*24:02:63")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_64():
    result = parse("A*24:02:64")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_65():
    result = parse("A*24:02:65")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_66():
    result = parse("A*24:02:66")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:66") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:66") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_67():
    result = parse("A*24:02:67")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:67") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:67") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_68():
    result = parse("A*24:02:68")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:68") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:68") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_69():
    result = parse("A*24:02:69")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:69") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:69") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_70():
    result = parse("A*24:02:70")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:70") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:70") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_71():
    result = parse("A*24:02:71")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:71") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:71") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_72():
    result = parse("A*24:02:72")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:72") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:72") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_73():
    result = parse("A*24:02:73")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:73") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:73") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_74():
    result = parse("A*24:02:74")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:74") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:74") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_75():
    result = parse("A*24:02:75")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:75") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:75") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_76():
    result = parse("A*24:02:76")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:76") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:76") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_77():
    result = parse("A*24:02:77")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:77") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:77") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_78():
    result = parse("A*24:02:78")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:78") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:78") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_79():
    result = parse("A*24:02:79")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:79") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:79") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_80():
    result = parse("A*24:02:80")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:80") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:80") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_81():
    result = parse("A*24:02:81")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:81") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:81") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_82():
    result = parse("A*24:02:82")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:82") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:82") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_83():
    result = parse("A*24:02:83")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:83") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:83") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_84():
    result = parse("A*24:02:84")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:84") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:84") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_85():
    result = parse("A*24:02:85")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:85") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:85") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_86():
    result = parse("A*24:02:86")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:86") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:86") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_87():
    result = parse("A*24:02:87")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:87") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:87") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_88():
    result = parse("A*24:02:88")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:88") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:88") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_89():
    result = parse("A*24:02:89")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:89") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:89") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_90():
    result = parse("A*24:02:90")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:90") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:90") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_91():
    result = parse("A*24:02:91")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:91") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:91") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_92():
    result = parse("A*24:02:92")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:92") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:92") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_93():
    result = parse("A*24:02:93")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:93") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:93") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_94():
    result = parse("A*24:02:94")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:94") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:94") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_95():
    result = parse("A*24:02:95")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:95") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:95") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_96():
    result = parse("A*24:02:96")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:96") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:96") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_97():
    result = parse("A*24:02:97")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:97") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:97") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_98():
    result = parse("A*24:02:98")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:98") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:98") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_02_99():
    result = parse("A*24:02:99")
    assert result.__class__ is Allele, f'Expected parse("A*24:02:99") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:02:99") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_03_01_01():
    result = parse("A*24:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_03_01_02():
    result = parse("A*24:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_03_01_03():
    result = parse("A*24:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_03_02():
    result = parse("A*24:03:02")
    assert result.__class__ is Allele, f'Expected parse("A*24:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_03_03():
    result = parse("A*24:03:03")
    assert result.__class__ is Allele, f'Expected parse("A*24:03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_03_04():
    result = parse("A*24:03:04")
    assert result.__class__ is Allele, f'Expected parse("A*24:03:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_04():
    result = parse("A*24:04")
    assert result.__class__ is Allele, f'Expected parse("A*24:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_05_01():
    result = parse("A*24:05:01")
    assert result.__class__ is Allele, f'Expected parse("A*24:05:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_05_02():
    result = parse("A*24:05:02")
    assert result.__class__ is Allele, f'Expected parse("A*24:05:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_06():
    result = parse("A*24:06")
    assert result.__class__ is Allele, f'Expected parse("A*24:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_07_01_01():
    result = parse("A*24:07:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:07:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:07:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_07_01_02():
    result = parse("A*24:07:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:07:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:07:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_07_01_03():
    result = parse("A*24:07:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:07:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:07:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_07_02():
    result = parse("A*24:07:02")
    assert result.__class__ is Allele, f'Expected parse("A*24:07:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_07_03():
    result = parse("A*24:07:03")
    assert result.__class__ is Allele, f'Expected parse("A*24:07:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:07:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_07_04():
    result = parse("A*24:07:04")
    assert result.__class__ is Allele, f'Expected parse("A*24:07:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:07:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_08():
    result = parse("A*24:08")
    assert result.__class__ is Allele, f'Expected parse("A*24:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_09N():
    result = parse("A*24:09N")
    assert result.__class__ is Allele, f'Expected parse("A*24:09N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:09N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_100():
    result = parse("A*24:100")
    assert result.__class__ is Allele, f'Expected parse("A*24:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_101():
    result = parse("A*24:101")
    assert result.__class__ is Allele, f'Expected parse("A*24:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_102():
    result = parse("A*24:102")
    assert result.__class__ is Allele, f'Expected parse("A*24:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_103():
    result = parse("A*24:103")
    assert result.__class__ is Allele, f'Expected parse("A*24:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_104():
    result = parse("A*24:104")
    assert result.__class__ is Allele, f'Expected parse("A*24:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_105():
    result = parse("A*24:105")
    assert result.__class__ is Allele, f'Expected parse("A*24:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_106():
    result = parse("A*24:106")
    assert result.__class__ is Allele, f'Expected parse("A*24:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_107():
    result = parse("A*24:107")
    assert result.__class__ is Allele, f'Expected parse("A*24:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_108():
    result = parse("A*24:108")
    assert result.__class__ is Allele, f'Expected parse("A*24:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_109():
    result = parse("A*24:109")
    assert result.__class__ is Allele, f'Expected parse("A*24:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_10_01_01():
    result = parse("A*24:10:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:10:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:10:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_10_01_02():
    result = parse("A*24:10:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:10:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:10:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_10_02():
    result = parse("A*24:10:02")
    assert result.__class__ is Allele, f'Expected parse("A*24:10:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:10:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_110():
    result = parse("A*24:110")
    assert result.__class__ is Allele, f'Expected parse("A*24:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_111():
    result = parse("A*24:111")
    assert result.__class__ is Allele, f'Expected parse("A*24:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_112():
    result = parse("A*24:112")
    assert result.__class__ is Allele, f'Expected parse("A*24:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_113():
    result = parse("A*24:113")
    assert result.__class__ is Allele, f'Expected parse("A*24:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_114():
    result = parse("A*24:114")
    assert result.__class__ is Allele, f'Expected parse("A*24:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_115():
    result = parse("A*24:115")
    assert result.__class__ is Allele, f'Expected parse("A*24:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_116():
    result = parse("A*24:116")
    assert result.__class__ is Allele, f'Expected parse("A*24:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_117():
    result = parse("A*24:117")
    assert result.__class__ is Allele, f'Expected parse("A*24:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_118():
    result = parse("A*24:118")
    assert result.__class__ is Allele, f'Expected parse("A*24:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_119():
    result = parse("A*24:119")
    assert result.__class__ is Allele, f'Expected parse("A*24:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_11N():
    result = parse("A*24:11N")
    assert result.__class__ is Allele, f'Expected parse("A*24:11N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:11N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_120():
    result = parse("A*24:120")
    assert result.__class__ is Allele, f'Expected parse("A*24:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_121():
    result = parse("A*24:121")
    assert result.__class__ is Allele, f'Expected parse("A*24:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_122():
    result = parse("A*24:122")
    assert result.__class__ is Allele, f'Expected parse("A*24:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_123():
    result = parse("A*24:123")
    assert result.__class__ is Allele, f'Expected parse("A*24:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_124():
    result = parse("A*24:124")
    assert result.__class__ is Allele, f'Expected parse("A*24:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_125():
    result = parse("A*24:125")
    assert result.__class__ is Allele, f'Expected parse("A*24:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_126():
    result = parse("A*24:126")
    assert result.__class__ is Allele, f'Expected parse("A*24:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_127():
    result = parse("A*24:127")
    assert result.__class__ is Allele, f'Expected parse("A*24:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_128():
    result = parse("A*24:128")
    assert result.__class__ is Allele, f'Expected parse("A*24:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_129():
    result = parse("A*24:129")
    assert result.__class__ is Allele, f'Expected parse("A*24:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_130():
    result = parse("A*24:130")
    assert result.__class__ is Allele, f'Expected parse("A*24:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_131():
    result = parse("A*24:131")
    assert result.__class__ is Allele, f'Expected parse("A*24:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_132N():
    result = parse("A*24:132N")
    assert result.__class__ is Allele, f'Expected parse("A*24:132N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:132N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_133():
    result = parse("A*24:133")
    assert result.__class__ is Allele, f'Expected parse("A*24:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_134():
    result = parse("A*24:134")
    assert result.__class__ is Allele, f'Expected parse("A*24:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_135_01():
    result = parse("A*24:135:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:135:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:135:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_135_02():
    result = parse("A*24:135:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:135:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:135:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_136():
    result = parse("A*24:136")
    assert result.__class__ is Allele, f'Expected parse("A*24:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_137():
    result = parse("A*24:137")
    assert result.__class__ is Allele, f'Expected parse("A*24:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_138():
    result = parse("A*24:138")
    assert result.__class__ is Allele, f'Expected parse("A*24:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_139():
    result = parse("A*24:139")
    assert result.__class__ is Allele, f'Expected parse("A*24:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_13_01():
    result = parse("A*24:13:01")
    assert result.__class__ is Allele, f'Expected parse("A*24:13:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:13:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_13_02():
    result = parse("A*24:13:02")
    assert result.__class__ is Allele, f'Expected parse("A*24:13:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:13:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_140():
    result = parse("A*24:140")
    assert result.__class__ is Allele, f'Expected parse("A*24:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_141():
    result = parse("A*24:141")
    assert result.__class__ is Allele, f'Expected parse("A*24:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_142_01():
    result = parse("A*24:142:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:142:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:142:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_142_02():
    result = parse("A*24:142:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:142:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:142:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_143():
    result = parse("A*24:143")
    assert result.__class__ is Allele, f'Expected parse("A*24:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_144():
    result = parse("A*24:144")
    assert result.__class__ is Allele, f'Expected parse("A*24:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_145():
    result = parse("A*24:145")
    assert result.__class__ is Allele, f'Expected parse("A*24:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_146():
    result = parse("A*24:146")
    assert result.__class__ is Allele, f'Expected parse("A*24:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_147():
    result = parse("A*24:147")
    assert result.__class__ is Allele, f'Expected parse("A*24:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_148():
    result = parse("A*24:148")
    assert result.__class__ is Allele, f'Expected parse("A*24:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_149():
    result = parse("A*24:149")
    assert result.__class__ is Allele, f'Expected parse("A*24:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_14_01_01():
    result = parse("A*24:14:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:14:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:14:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_14_01_02():
    result = parse("A*24:14:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:14:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:14:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_14_01_03():
    result = parse("A*24:14:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:14:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:14:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_14_01_04():
    result = parse("A*24:14:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:14:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:14:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_15():
    result = parse("A*24:15")
    assert result.__class__ is Allele, f'Expected parse("A*24:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_150():
    result = parse("A*24:150")
    assert result.__class__ is Allele, f'Expected parse("A*24:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_151():
    result = parse("A*24:151")
    assert result.__class__ is Allele, f'Expected parse("A*24:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_152():
    result = parse("A*24:152")
    assert result.__class__ is Allele, f'Expected parse("A*24:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_153():
    result = parse("A*24:153")
    assert result.__class__ is Allele, f'Expected parse("A*24:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_154():
    result = parse("A*24:154")
    assert result.__class__ is Allele, f'Expected parse("A*24:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_155N():
    result = parse("A*24:155N")
    assert result.__class__ is Allele, f'Expected parse("A*24:155N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:155N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_156():
    result = parse("A*24:156")
    assert result.__class__ is Allele, f'Expected parse("A*24:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_157():
    result = parse("A*24:157")
    assert result.__class__ is Allele, f'Expected parse("A*24:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_158N():
    result = parse("A*24:158N")
    assert result.__class__ is Allele, f'Expected parse("A*24:158N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:158N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_159():
    result = parse("A*24:159")
    assert result.__class__ is Allele, f'Expected parse("A*24:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_160():
    result = parse("A*24:160")
    assert result.__class__ is Allele, f'Expected parse("A*24:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_161():
    result = parse("A*24:161")
    assert result.__class__ is Allele, f'Expected parse("A*24:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_162():
    result = parse("A*24:162")
    assert result.__class__ is Allele, f'Expected parse("A*24:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_163N():
    result = parse("A*24:163N")
    assert result.__class__ is Allele, f'Expected parse("A*24:163N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:163N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_164():
    result = parse("A*24:164")
    assert result.__class__ is Allele, f'Expected parse("A*24:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_165():
    result = parse("A*24:165")
    assert result.__class__ is Allele, f'Expected parse("A*24:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_166():
    result = parse("A*24:166")
    assert result.__class__ is Allele, f'Expected parse("A*24:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_167():
    result = parse("A*24:167")
    assert result.__class__ is Allele, f'Expected parse("A*24:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_168():
    result = parse("A*24:168")
    assert result.__class__ is Allele, f'Expected parse("A*24:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_169():
    result = parse("A*24:169")
    assert result.__class__ is Allele, f'Expected parse("A*24:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_17():
    result = parse("A*24:17")
    assert result.__class__ is Allele, f'Expected parse("A*24:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_170():
    result = parse("A*24:170")
    assert result.__class__ is Allele, f'Expected parse("A*24:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_171():
    result = parse("A*24:171")
    assert result.__class__ is Allele, f'Expected parse("A*24:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_172_01():
    result = parse("A*24:172:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:172:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:172:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_172_02():
    result = parse("A*24:172:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:172:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:172:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_173():
    result = parse("A*24:173")
    assert result.__class__ is Allele, f'Expected parse("A*24:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_174():
    result = parse("A*24:174")
    assert result.__class__ is Allele, f'Expected parse("A*24:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_175():
    result = parse("A*24:175")
    assert result.__class__ is Allele, f'Expected parse("A*24:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_176():
    result = parse("A*24:176")
    assert result.__class__ is Allele, f'Expected parse("A*24:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_177():
    result = parse("A*24:177")
    assert result.__class__ is Allele, f'Expected parse("A*24:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_178():
    result = parse("A*24:178")
    assert result.__class__ is Allele, f'Expected parse("A*24:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_179():
    result = parse("A*24:179")
    assert result.__class__ is Allele, f'Expected parse("A*24:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_18():
    result = parse("A*24:18")
    assert result.__class__ is Allele, f'Expected parse("A*24:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_180():
    result = parse("A*24:180")
    assert result.__class__ is Allele, f'Expected parse("A*24:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_181():
    result = parse("A*24:181")
    assert result.__class__ is Allele, f'Expected parse("A*24:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_182():
    result = parse("A*24:182")
    assert result.__class__ is Allele, f'Expected parse("A*24:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_183N():
    result = parse("A*24:183N")
    assert result.__class__ is Allele, f'Expected parse("A*24:183N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:183N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_184():
    result = parse("A*24:184")
    assert result.__class__ is Allele, f'Expected parse("A*24:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_185N():
    result = parse("A*24:185N")
    assert result.__class__ is Allele, f'Expected parse("A*24:185N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:185N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_186():
    result = parse("A*24:186")
    assert result.__class__ is Allele, f'Expected parse("A*24:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_187():
    result = parse("A*24:187")
    assert result.__class__ is Allele, f'Expected parse("A*24:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_188():
    result = parse("A*24:188")
    assert result.__class__ is Allele, f'Expected parse("A*24:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_189():
    result = parse("A*24:189")
    assert result.__class__ is Allele, f'Expected parse("A*24:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_19():
    result = parse("A*24:19")
    assert result.__class__ is Allele, f'Expected parse("A*24:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_190():
    result = parse("A*24:190")
    assert result.__class__ is Allele, f'Expected parse("A*24:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_191():
    result = parse("A*24:191")
    assert result.__class__ is Allele, f'Expected parse("A*24:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_192():
    result = parse("A*24:192")
    assert result.__class__ is Allele, f'Expected parse("A*24:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_193():
    result = parse("A*24:193")
    assert result.__class__ is Allele, f'Expected parse("A*24:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_194():
    result = parse("A*24:194")
    assert result.__class__ is Allele, f'Expected parse("A*24:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_195():
    result = parse("A*24:195")
    assert result.__class__ is Allele, f'Expected parse("A*24:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_196():
    result = parse("A*24:196")
    assert result.__class__ is Allele, f'Expected parse("A*24:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_197():
    result = parse("A*24:197")
    assert result.__class__ is Allele, f'Expected parse("A*24:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_198():
    result = parse("A*24:198")
    assert result.__class__ is Allele, f'Expected parse("A*24:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_199():
    result = parse("A*24:199")
    assert result.__class__ is Allele, f'Expected parse("A*24:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_200():
    result = parse("A*24:200")
    assert result.__class__ is Allele, f'Expected parse("A*24:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_201():
    result = parse("A*24:201")
    assert result.__class__ is Allele, f'Expected parse("A*24:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_202():
    result = parse("A*24:202")
    assert result.__class__ is Allele, f'Expected parse("A*24:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_203():
    result = parse("A*24:203")
    assert result.__class__ is Allele, f'Expected parse("A*24:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_204():
    result = parse("A*24:204")
    assert result.__class__ is Allele, f'Expected parse("A*24:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_205():
    result = parse("A*24:205")
    assert result.__class__ is Allele, f'Expected parse("A*24:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_206():
    result = parse("A*24:206")
    assert result.__class__ is Allele, f'Expected parse("A*24:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_207_01():
    result = parse("A*24:207:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:207:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:207:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_207_02():
    result = parse("A*24:207:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:207:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:207:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_208_01():
    result = parse("A*24:208:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:208:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:208:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_208_02():
    result = parse("A*24:208:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:208:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:208:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_209():
    result = parse("A*24:209")
    assert result.__class__ is Allele, f'Expected parse("A*24:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_20_01_01():
    result = parse("A*24:20:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:20:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:20:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_20_01_02():
    result = parse("A*24:20:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:20:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*24:20:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_210():
    result = parse("A*24:210")
    assert result.__class__ is Allele, f'Expected parse("A*24:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_212():
    result = parse("A*24:212")
    assert result.__class__ is Allele, f'Expected parse("A*24:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_213():
    result = parse("A*24:213")
    assert result.__class__ is Allele, f'Expected parse("A*24:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_214():
    result = parse("A*24:214")
    assert result.__class__ is Allele, f'Expected parse("A*24:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_215():
    result = parse("A*24:215")
    assert result.__class__ is Allele, f'Expected parse("A*24:215") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_216():
    result = parse("A*24:216")
    assert result.__class__ is Allele, f'Expected parse("A*24:216") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_217():
    result = parse("A*24:217")
    assert result.__class__ is Allele, f'Expected parse("A*24:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_218():
    result = parse("A*24:218")
    assert result.__class__ is Allele, f'Expected parse("A*24:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_219():
    result = parse("A*24:219")
    assert result.__class__ is Allele, f'Expected parse("A*24:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_21_01():
    result = parse("A*24:21:01")
    assert result.__class__ is Allele, f'Expected parse("A*24:21:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:21:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_21_02():
    result = parse("A*24:21:02")
    assert result.__class__ is Allele, f'Expected parse("A*24:21:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:21:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_21_03():
    result = parse("A*24:21:03")
    assert result.__class__ is Allele, f'Expected parse("A*24:21:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:21:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_22():
    result = parse("A*24:22")
    assert result.__class__ is Allele, f'Expected parse("A*24:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_220():
    result = parse("A*24:220")
    assert result.__class__ is Allele, f'Expected parse("A*24:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_221():
    result = parse("A*24:221")
    assert result.__class__ is Allele, f'Expected parse("A*24:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_222N():
    result = parse("A*24:222N")
    assert result.__class__ is Allele, f'Expected parse("A*24:222N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:222N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_223():
    result = parse("A*24:223")
    assert result.__class__ is Allele, f'Expected parse("A*24:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_224():
    result = parse("A*24:224")
    assert result.__class__ is Allele, f'Expected parse("A*24:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_225_01():
    result = parse("A*24:225:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:225:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:225:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_225_02():
    result = parse("A*24:225:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:225:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:225:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_226_01():
    result = parse("A*24:226:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:226:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:226:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_226_02():
    result = parse("A*24:226:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:226:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:226:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_227():
    result = parse("A*24:227")
    assert result.__class__ is Allele, f'Expected parse("A*24:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_228():
    result = parse("A*24:228")
    assert result.__class__ is Allele, f'Expected parse("A*24:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_229():
    result = parse("A*24:229")
    assert result.__class__ is Allele, f'Expected parse("A*24:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_23():
    result = parse("A*24:23")
    assert result.__class__ is Allele, f'Expected parse("A*24:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_230():
    result = parse("A*24:230")
    assert result.__class__ is Allele, f'Expected parse("A*24:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_231():
    result = parse("A*24:231")
    assert result.__class__ is Allele, f'Expected parse("A*24:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_232N():
    result = parse("A*24:232N")
    assert result.__class__ is Allele, f'Expected parse("A*24:232N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:232N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_233():
    result = parse("A*24:233")
    assert result.__class__ is Allele, f'Expected parse("A*24:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_234():
    result = parse("A*24:234")
    assert result.__class__ is Allele, f'Expected parse("A*24:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_235():
    result = parse("A*24:235")
    assert result.__class__ is Allele, f'Expected parse("A*24:235") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_236():
    result = parse("A*24:236")
    assert result.__class__ is Allele, f'Expected parse("A*24:236") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_237():
    result = parse("A*24:237")
    assert result.__class__ is Allele, f'Expected parse("A*24:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_238():
    result = parse("A*24:238")
    assert result.__class__ is Allele, f'Expected parse("A*24:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_239():
    result = parse("A*24:239")
    assert result.__class__ is Allele, f'Expected parse("A*24:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_24():
    result = parse("A*24:24")
    assert result.__class__ is Allele, f'Expected parse("A*24:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_240N():
    result = parse("A*24:240N")
    assert result.__class__ is Allele, f'Expected parse("A*24:240N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:240N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_241():
    result = parse("A*24:241")
    assert result.__class__ is Allele, f'Expected parse("A*24:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_242():
    result = parse("A*24:242")
    assert result.__class__ is Allele, f'Expected parse("A*24:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_243():
    result = parse("A*24:243")
    assert result.__class__ is Allele, f'Expected parse("A*24:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_244():
    result = parse("A*24:244")
    assert result.__class__ is Allele, f'Expected parse("A*24:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_245():
    result = parse("A*24:245")
    assert result.__class__ is Allele, f'Expected parse("A*24:245") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_246():
    result = parse("A*24:246")
    assert result.__class__ is Allele, f'Expected parse("A*24:246") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_247():
    result = parse("A*24:247")
    assert result.__class__ is Allele, f'Expected parse("A*24:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_248():
    result = parse("A*24:248")
    assert result.__class__ is Allele, f'Expected parse("A*24:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_249():
    result = parse("A*24:249")
    assert result.__class__ is Allele, f'Expected parse("A*24:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_25():
    result = parse("A*24:25")
    assert result.__class__ is Allele, f'Expected parse("A*24:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_250():
    result = parse("A*24:250")
    assert result.__class__ is Allele, f'Expected parse("A*24:250") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_251():
    result = parse("A*24:251")
    assert result.__class__ is Allele, f'Expected parse("A*24:251") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_252N():
    result = parse("A*24:252N")
    assert result.__class__ is Allele, f'Expected parse("A*24:252N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:252N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_253():
    result = parse("A*24:253")
    assert result.__class__ is Allele, f'Expected parse("A*24:253") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_254():
    result = parse("A*24:254")
    assert result.__class__ is Allele, f'Expected parse("A*24:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_255():
    result = parse("A*24:255")
    assert result.__class__ is Allele, f'Expected parse("A*24:255") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_256():
    result = parse("A*24:256")
    assert result.__class__ is Allele, f'Expected parse("A*24:256") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_257():
    result = parse("A*24:257")
    assert result.__class__ is Allele, f'Expected parse("A*24:257") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_258():
    result = parse("A*24:258")
    assert result.__class__ is Allele, f'Expected parse("A*24:258") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_259():
    result = parse("A*24:259")
    assert result.__class__ is Allele, f'Expected parse("A*24:259") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_26():
    result = parse("A*24:26")
    assert result.__class__ is Allele, f'Expected parse("A*24:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_260():
    result = parse("A*24:260")
    assert result.__class__ is Allele, f'Expected parse("A*24:260") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_261():
    result = parse("A*24:261")
    assert result.__class__ is Allele, f'Expected parse("A*24:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_262():
    result = parse("A*24:262")
    assert result.__class__ is Allele, f'Expected parse("A*24:262") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_263():
    result = parse("A*24:263")
    assert result.__class__ is Allele, f'Expected parse("A*24:263") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_264():
    result = parse("A*24:264")
    assert result.__class__ is Allele, f'Expected parse("A*24:264") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_265():
    result = parse("A*24:265")
    assert result.__class__ is Allele, f'Expected parse("A*24:265") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_266():
    result = parse("A*24:266")
    assert result.__class__ is Allele, f'Expected parse("A*24:266") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_267():
    result = parse("A*24:267")
    assert result.__class__ is Allele, f'Expected parse("A*24:267") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_268():
    result = parse("A*24:268")
    assert result.__class__ is Allele, f'Expected parse("A*24:268") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_269():
    result = parse("A*24:269")
    assert result.__class__ is Allele, f'Expected parse("A*24:269") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_27():
    result = parse("A*24:27")
    assert result.__class__ is Allele, f'Expected parse("A*24:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_270():
    result = parse("A*24:270")
    assert result.__class__ is Allele, f'Expected parse("A*24:270") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_271():
    result = parse("A*24:271")
    assert result.__class__ is Allele, f'Expected parse("A*24:271") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_272():
    result = parse("A*24:272")
    assert result.__class__ is Allele, f'Expected parse("A*24:272") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_273():
    result = parse("A*24:273")
    assert result.__class__ is Allele, f'Expected parse("A*24:273") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_274():
    result = parse("A*24:274")
    assert result.__class__ is Allele, f'Expected parse("A*24:274") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_275():
    result = parse("A*24:275")
    assert result.__class__ is Allele, f'Expected parse("A*24:275") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_276():
    result = parse("A*24:276")
    assert result.__class__ is Allele, f'Expected parse("A*24:276") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_277():
    result = parse("A*24:277")
    assert result.__class__ is Allele, f'Expected parse("A*24:277") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_278N():
    result = parse("A*24:278N")
    assert result.__class__ is Allele, f'Expected parse("A*24:278N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:278N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_279():
    result = parse("A*24:279")
    assert result.__class__ is Allele, f'Expected parse("A*24:279") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_28():
    result = parse("A*24:28")
    assert result.__class__ is Allele, f'Expected parse("A*24:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_280():
    result = parse("A*24:280")
    assert result.__class__ is Allele, f'Expected parse("A*24:280") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_281():
    result = parse("A*24:281")
    assert result.__class__ is Allele, f'Expected parse("A*24:281") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_282():
    result = parse("A*24:282")
    assert result.__class__ is Allele, f'Expected parse("A*24:282") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_283():
    result = parse("A*24:283")
    assert result.__class__ is Allele, f'Expected parse("A*24:283") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_284():
    result = parse("A*24:284")
    assert result.__class__ is Allele, f'Expected parse("A*24:284") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_285():
    result = parse("A*24:285")
    assert result.__class__ is Allele, f'Expected parse("A*24:285") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_286():
    result = parse("A*24:286")
    assert result.__class__ is Allele, f'Expected parse("A*24:286") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_287():
    result = parse("A*24:287")
    assert result.__class__ is Allele, f'Expected parse("A*24:287") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:287") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_288():
    result = parse("A*24:288")
    assert result.__class__ is Allele, f'Expected parse("A*24:288") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_289():
    result = parse("A*24:289")
    assert result.__class__ is Allele, f'Expected parse("A*24:289") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_29():
    result = parse("A*24:29")
    assert result.__class__ is Allele, f'Expected parse("A*24:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_290():
    result = parse("A*24:290")
    assert result.__class__ is Allele, f'Expected parse("A*24:290") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_291():
    result = parse("A*24:291")
    assert result.__class__ is Allele, f'Expected parse("A*24:291") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_292():
    result = parse("A*24:292")
    assert result.__class__ is Allele, f'Expected parse("A*24:292") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_293():
    result = parse("A*24:293")
    assert result.__class__ is Allele, f'Expected parse("A*24:293") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_294Q():
    result = parse("A*24:294Q")
    assert result.__class__ is Allele, f'Expected parse("A*24:294Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:294Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_295():
    result = parse("A*24:295")
    assert result.__class__ is Allele, f'Expected parse("A*24:295") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_296():
    result = parse("A*24:296")
    assert result.__class__ is Allele, f'Expected parse("A*24:296") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_297():
    result = parse("A*24:297")
    assert result.__class__ is Allele, f'Expected parse("A*24:297") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_298():
    result = parse("A*24:298")
    assert result.__class__ is Allele, f'Expected parse("A*24:298") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_299():
    result = parse("A*24:299")
    assert result.__class__ is Allele, f'Expected parse("A*24:299") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_30():
    result = parse("A*24:30")
    assert result.__class__ is Allele, f'Expected parse("A*24:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_300():
    result = parse("A*24:300")
    assert result.__class__ is Allele, f'Expected parse("A*24:300") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_301():
    result = parse("A*24:301")
    assert result.__class__ is Allele, f'Expected parse("A*24:301") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_302():
    result = parse("A*24:302")
    assert result.__class__ is Allele, f'Expected parse("A*24:302") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_303N():
    result = parse("A*24:303N")
    assert result.__class__ is Allele, f'Expected parse("A*24:303N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:303N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_304():
    result = parse("A*24:304")
    assert result.__class__ is Allele, f'Expected parse("A*24:304") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:304") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_305():
    result = parse("A*24:305")
    assert result.__class__ is Allele, f'Expected parse("A*24:305") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_306():
    result = parse("A*24:306")
    assert result.__class__ is Allele, f'Expected parse("A*24:306") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:306") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_307():
    result = parse("A*24:307")
    assert result.__class__ is Allele, f'Expected parse("A*24:307") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_308():
    result = parse("A*24:308")
    assert result.__class__ is Allele, f'Expected parse("A*24:308") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:308") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_309():
    result = parse("A*24:309")
    assert result.__class__ is Allele, f'Expected parse("A*24:309") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:309") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_31():
    result = parse("A*24:31")
    assert result.__class__ is Allele, f'Expected parse("A*24:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_310_01():
    result = parse("A*24:310:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:310:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:310:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_310_02():
    result = parse("A*24:310:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:310:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:310:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_311():
    result = parse("A*24:311")
    assert result.__class__ is Allele, f'Expected parse("A*24:311") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:311") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_312N():
    result = parse("A*24:312N")
    assert result.__class__ is Allele, f'Expected parse("A*24:312N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:312N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_313_01():
    result = parse("A*24:313:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:313:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:313:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_313_02():
    result = parse("A*24:313:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:313:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:313:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_314():
    result = parse("A*24:314")
    assert result.__class__ is Allele, f'Expected parse("A*24:314") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:314") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_315():
    result = parse("A*24:315")
    assert result.__class__ is Allele, f'Expected parse("A*24:315") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:315") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_316():
    result = parse("A*24:316")
    assert result.__class__ is Allele, f'Expected parse("A*24:316") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:316") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_317():
    result = parse("A*24:317")
    assert result.__class__ is Allele, f'Expected parse("A*24:317") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:317") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_318():
    result = parse("A*24:318")
    assert result.__class__ is Allele, f'Expected parse("A*24:318") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:318") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_319():
    result = parse("A*24:319")
    assert result.__class__ is Allele, f'Expected parse("A*24:319") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_32():
    result = parse("A*24:32")
    assert result.__class__ is Allele, f'Expected parse("A*24:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_320():
    result = parse("A*24:320")
    assert result.__class__ is Allele, f'Expected parse("A*24:320") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:320") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_321():
    result = parse("A*24:321")
    assert result.__class__ is Allele, f'Expected parse("A*24:321") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:321") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_322():
    result = parse("A*24:322")
    assert result.__class__ is Allele, f'Expected parse("A*24:322") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:322") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_323N():
    result = parse("A*24:323N")
    assert result.__class__ is Allele, f'Expected parse("A*24:323N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:323N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_324():
    result = parse("A*24:324")
    assert result.__class__ is Allele, f'Expected parse("A*24:324") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:324") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_325():
    result = parse("A*24:325")
    assert result.__class__ is Allele, f'Expected parse("A*24:325") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:325") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_326():
    result = parse("A*24:326")
    assert result.__class__ is Allele, f'Expected parse("A*24:326") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:326") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_327():
    result = parse("A*24:327")
    assert result.__class__ is Allele, f'Expected parse("A*24:327") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:327") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_328():
    result = parse("A*24:328")
    assert result.__class__ is Allele, f'Expected parse("A*24:328") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:328") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_329Q():
    result = parse("A*24:329Q")
    assert result.__class__ is Allele, f'Expected parse("A*24:329Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:329Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_33():
    result = parse("A*24:33")
    assert result.__class__ is Allele, f'Expected parse("A*24:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_330():
    result = parse("A*24:330")
    assert result.__class__ is Allele, f'Expected parse("A*24:330") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:330") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_331():
    result = parse("A*24:331")
    assert result.__class__ is Allele, f'Expected parse("A*24:331") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:331") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_332():
    result = parse("A*24:332")
    assert result.__class__ is Allele, f'Expected parse("A*24:332") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:332") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_333():
    result = parse("A*24:333")
    assert result.__class__ is Allele, f'Expected parse("A*24:333") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:333") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_334():
    result = parse("A*24:334")
    assert result.__class__ is Allele, f'Expected parse("A*24:334") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:334") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_335():
    result = parse("A*24:335")
    assert result.__class__ is Allele, f'Expected parse("A*24:335") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:335") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_336():
    result = parse("A*24:336")
    assert result.__class__ is Allele, f'Expected parse("A*24:336") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:336") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_337():
    result = parse("A*24:337")
    assert result.__class__ is Allele, f'Expected parse("A*24:337") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:337") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_338():
    result = parse("A*24:338")
    assert result.__class__ is Allele, f'Expected parse("A*24:338") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:338") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_339():
    result = parse("A*24:339")
    assert result.__class__ is Allele, f'Expected parse("A*24:339") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:339") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_34():
    result = parse("A*24:34")
    assert result.__class__ is Allele, f'Expected parse("A*24:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_340():
    result = parse("A*24:340")
    assert result.__class__ is Allele, f'Expected parse("A*24:340") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:340") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_341():
    result = parse("A*24:341")
    assert result.__class__ is Allele, f'Expected parse("A*24:341") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:341") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_342():
    result = parse("A*24:342")
    assert result.__class__ is Allele, f'Expected parse("A*24:342") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:342") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_343():
    result = parse("A*24:343")
    assert result.__class__ is Allele, f'Expected parse("A*24:343") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:343") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_344():
    result = parse("A*24:344")
    assert result.__class__ is Allele, f'Expected parse("A*24:344") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:344") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_345():
    result = parse("A*24:345")
    assert result.__class__ is Allele, f'Expected parse("A*24:345") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:345") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_346():
    result = parse("A*24:346")
    assert result.__class__ is Allele, f'Expected parse("A*24:346") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:346") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_347_01():
    result = parse("A*24:347:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:347:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:347:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_347_02():
    result = parse("A*24:347:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:347:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:347:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_348():
    result = parse("A*24:348")
    assert result.__class__ is Allele, f'Expected parse("A*24:348") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:348") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_349():
    result = parse("A*24:349")
    assert result.__class__ is Allele, f'Expected parse("A*24:349") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:349") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_35():
    result = parse("A*24:35")
    assert result.__class__ is Allele, f'Expected parse("A*24:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_350():
    result = parse("A*24:350")
    assert result.__class__ is Allele, f'Expected parse("A*24:350") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:350") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_351():
    result = parse("A*24:351")
    assert result.__class__ is Allele, f'Expected parse("A*24:351") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:351") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_352():
    result = parse("A*24:352")
    assert result.__class__ is Allele, f'Expected parse("A*24:352") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:352") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_353():
    result = parse("A*24:353")
    assert result.__class__ is Allele, f'Expected parse("A*24:353") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:353") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_354():
    result = parse("A*24:354")
    assert result.__class__ is Allele, f'Expected parse("A*24:354") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:354") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_355():
    result = parse("A*24:355")
    assert result.__class__ is Allele, f'Expected parse("A*24:355") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:355") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_356():
    result = parse("A*24:356")
    assert result.__class__ is Allele, f'Expected parse("A*24:356") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:356") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_357N():
    result = parse("A*24:357N")
    assert result.__class__ is Allele, f'Expected parse("A*24:357N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:357N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_358():
    result = parse("A*24:358")
    assert result.__class__ is Allele, f'Expected parse("A*24:358") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:358") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_359N():
    result = parse("A*24:359N")
    assert result.__class__ is Allele, f'Expected parse("A*24:359N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:359N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_360():
    result = parse("A*24:360")
    assert result.__class__ is Allele, f'Expected parse("A*24:360") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:360") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_361():
    result = parse("A*24:361")
    assert result.__class__ is Allele, f'Expected parse("A*24:361") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:361") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_362():
    result = parse("A*24:362")
    assert result.__class__ is Allele, f'Expected parse("A*24:362") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:362") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_363():
    result = parse("A*24:363")
    assert result.__class__ is Allele, f'Expected parse("A*24:363") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:363") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_364():
    result = parse("A*24:364")
    assert result.__class__ is Allele, f'Expected parse("A*24:364") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:364") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_365():
    result = parse("A*24:365")
    assert result.__class__ is Allele, f'Expected parse("A*24:365") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:365") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_366():
    result = parse("A*24:366")
    assert result.__class__ is Allele, f'Expected parse("A*24:366") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:366") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_367():
    result = parse("A*24:367")
    assert result.__class__ is Allele, f'Expected parse("A*24:367") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:367") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_368():
    result = parse("A*24:368")
    assert result.__class__ is Allele, f'Expected parse("A*24:368") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:368") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_369():
    result = parse("A*24:369")
    assert result.__class__ is Allele, f'Expected parse("A*24:369") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:369") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_36N():
    result = parse("A*24:36N")
    assert result.__class__ is Allele, f'Expected parse("A*24:36N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:36N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_37():
    result = parse("A*24:37")
    assert result.__class__ is Allele, f'Expected parse("A*24:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_370N():
    result = parse("A*24:370N")
    assert result.__class__ is Allele, f'Expected parse("A*24:370N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:370N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_371():
    result = parse("A*24:371")
    assert result.__class__ is Allele, f'Expected parse("A*24:371") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:371") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_372():
    result = parse("A*24:372")
    assert result.__class__ is Allele, f'Expected parse("A*24:372") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:372") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_373():
    result = parse("A*24:373")
    assert result.__class__ is Allele, f'Expected parse("A*24:373") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:373") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_374():
    result = parse("A*24:374")
    assert result.__class__ is Allele, f'Expected parse("A*24:374") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:374") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_375():
    result = parse("A*24:375")
    assert result.__class__ is Allele, f'Expected parse("A*24:375") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:375") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_376():
    result = parse("A*24:376")
    assert result.__class__ is Allele, f'Expected parse("A*24:376") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:376") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_377():
    result = parse("A*24:377")
    assert result.__class__ is Allele, f'Expected parse("A*24:377") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:377") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_378Q():
    result = parse("A*24:378Q")
    assert result.__class__ is Allele, f'Expected parse("A*24:378Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:378Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_379():
    result = parse("A*24:379")
    assert result.__class__ is Allele, f'Expected parse("A*24:379") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:379") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_38():
    result = parse("A*24:38")
    assert result.__class__ is Allele, f'Expected parse("A*24:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_380():
    result = parse("A*24:380")
    assert result.__class__ is Allele, f'Expected parse("A*24:380") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:380") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_381():
    result = parse("A*24:381")
    assert result.__class__ is Allele, f'Expected parse("A*24:381") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:381") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_382():
    result = parse("A*24:382")
    assert result.__class__ is Allele, f'Expected parse("A*24:382") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:382") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_383():
    result = parse("A*24:383")
    assert result.__class__ is Allele, f'Expected parse("A*24:383") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:383") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_384():
    result = parse("A*24:384")
    assert result.__class__ is Allele, f'Expected parse("A*24:384") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:384") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_385():
    result = parse("A*24:385")
    assert result.__class__ is Allele, f'Expected parse("A*24:385") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:385") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_386():
    result = parse("A*24:386")
    assert result.__class__ is Allele, f'Expected parse("A*24:386") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:386") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_387():
    result = parse("A*24:387")
    assert result.__class__ is Allele, f'Expected parse("A*24:387") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:387") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_388N():
    result = parse("A*24:388N")
    assert result.__class__ is Allele, f'Expected parse("A*24:388N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:388N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_389N():
    result = parse("A*24:389N")
    assert result.__class__ is Allele, f'Expected parse("A*24:389N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:389N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_39():
    result = parse("A*24:39")
    assert result.__class__ is Allele, f'Expected parse("A*24:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_390():
    result = parse("A*24:390")
    assert result.__class__ is Allele, f'Expected parse("A*24:390") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:390") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_391():
    result = parse("A*24:391")
    assert result.__class__ is Allele, f'Expected parse("A*24:391") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:391") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_392():
    result = parse("A*24:392")
    assert result.__class__ is Allele, f'Expected parse("A*24:392") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:392") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_393():
    result = parse("A*24:393")
    assert result.__class__ is Allele, f'Expected parse("A*24:393") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:393") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_394():
    result = parse("A*24:394")
    assert result.__class__ is Allele, f'Expected parse("A*24:394") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:394") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_395():
    result = parse("A*24:395")
    assert result.__class__ is Allele, f'Expected parse("A*24:395") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:395") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_396N():
    result = parse("A*24:396N")
    assert result.__class__ is Allele, f'Expected parse("A*24:396N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:396N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_397():
    result = parse("A*24:397")
    assert result.__class__ is Allele, f'Expected parse("A*24:397") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:397") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_398():
    result = parse("A*24:398")
    assert result.__class__ is Allele, f'Expected parse("A*24:398") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:398") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_399():
    result = parse("A*24:399")
    assert result.__class__ is Allele, f'Expected parse("A*24:399") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:399") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_400():
    result = parse("A*24:400")
    assert result.__class__ is Allele, f'Expected parse("A*24:400") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:400") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_401():
    result = parse("A*24:401")
    assert result.__class__ is Allele, f'Expected parse("A*24:401") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:401") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_402():
    result = parse("A*24:402")
    assert result.__class__ is Allele, f'Expected parse("A*24:402") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:402") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_403():
    result = parse("A*24:403")
    assert result.__class__ is Allele, f'Expected parse("A*24:403") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:403") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_404():
    result = parse("A*24:404")
    assert result.__class__ is Allele, f'Expected parse("A*24:404") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:404") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_405():
    result = parse("A*24:405")
    assert result.__class__ is Allele, f'Expected parse("A*24:405") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:405") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_406():
    result = parse("A*24:406")
    assert result.__class__ is Allele, f'Expected parse("A*24:406") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:406") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_407():
    result = parse("A*24:407")
    assert result.__class__ is Allele, f'Expected parse("A*24:407") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:407") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_408N():
    result = parse("A*24:408N")
    assert result.__class__ is Allele, f'Expected parse("A*24:408N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:408N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_409():
    result = parse("A*24:409")
    assert result.__class__ is Allele, f'Expected parse("A*24:409") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:409") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_40N():
    result = parse("A*24:40N")
    assert result.__class__ is Allele, f'Expected parse("A*24:40N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:40N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_41():
    result = parse("A*24:41")
    assert result.__class__ is Allele, f'Expected parse("A*24:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_410():
    result = parse("A*24:410")
    assert result.__class__ is Allele, f'Expected parse("A*24:410") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:410") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_411():
    result = parse("A*24:411")
    assert result.__class__ is Allele, f'Expected parse("A*24:411") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:411") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_412():
    result = parse("A*24:412")
    assert result.__class__ is Allele, f'Expected parse("A*24:412") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:412") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_413():
    result = parse("A*24:413")
    assert result.__class__ is Allele, f'Expected parse("A*24:413") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:413") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_414():
    result = parse("A*24:414")
    assert result.__class__ is Allele, f'Expected parse("A*24:414") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:414") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_415():
    result = parse("A*24:415")
    assert result.__class__ is Allele, f'Expected parse("A*24:415") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:415") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_416():
    result = parse("A*24:416")
    assert result.__class__ is Allele, f'Expected parse("A*24:416") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:416") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_417():
    result = parse("A*24:417")
    assert result.__class__ is Allele, f'Expected parse("A*24:417") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:417") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_418():
    result = parse("A*24:418")
    assert result.__class__ is Allele, f'Expected parse("A*24:418") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:418") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_419():
    result = parse("A*24:419")
    assert result.__class__ is Allele, f'Expected parse("A*24:419") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:419") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_42():
    result = parse("A*24:42")
    assert result.__class__ is Allele, f'Expected parse("A*24:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_420():
    result = parse("A*24:420")
    assert result.__class__ is Allele, f'Expected parse("A*24:420") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:420") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_421():
    result = parse("A*24:421")
    assert result.__class__ is Allele, f'Expected parse("A*24:421") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:421") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_422():
    result = parse("A*24:422")
    assert result.__class__ is Allele, f'Expected parse("A*24:422") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:422") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_423():
    result = parse("A*24:423")
    assert result.__class__ is Allele, f'Expected parse("A*24:423") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:423") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_424():
    result = parse("A*24:424")
    assert result.__class__ is Allele, f'Expected parse("A*24:424") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:424") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_425N():
    result = parse("A*24:425N")
    assert result.__class__ is Allele, f'Expected parse("A*24:425N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:425N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_426N():
    result = parse("A*24:426N")
    assert result.__class__ is Allele, f'Expected parse("A*24:426N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:426N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_427N():
    result = parse("A*24:427N")
    assert result.__class__ is Allele, f'Expected parse("A*24:427N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:427N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_428N():
    result = parse("A*24:428N")
    assert result.__class__ is Allele, f'Expected parse("A*24:428N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:428N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_429N():
    result = parse("A*24:429N")
    assert result.__class__ is Allele, f'Expected parse("A*24:429N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:429N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_43():
    result = parse("A*24:43")
    assert result.__class__ is Allele, f'Expected parse("A*24:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_430N():
    result = parse("A*24:430N")
    assert result.__class__ is Allele, f'Expected parse("A*24:430N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:430N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_431():
    result = parse("A*24:431")
    assert result.__class__ is Allele, f'Expected parse("A*24:431") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:431") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_432():
    result = parse("A*24:432")
    assert result.__class__ is Allele, f'Expected parse("A*24:432") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:432") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_433N():
    result = parse("A*24:433N")
    assert result.__class__ is Allele, f'Expected parse("A*24:433N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:433N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_434N():
    result = parse("A*24:434N")
    assert result.__class__ is Allele, f'Expected parse("A*24:434N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:434N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_435N():
    result = parse("A*24:435N")
    assert result.__class__ is Allele, f'Expected parse("A*24:435N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:435N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_436():
    result = parse("A*24:436")
    assert result.__class__ is Allele, f'Expected parse("A*24:436") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:436") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_437():
    result = parse("A*24:437")
    assert result.__class__ is Allele, f'Expected parse("A*24:437") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:437") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_438():
    result = parse("A*24:438")
    assert result.__class__ is Allele, f'Expected parse("A*24:438") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:438") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_439():
    result = parse("A*24:439")
    assert result.__class__ is Allele, f'Expected parse("A*24:439") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:439") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_44():
    result = parse("A*24:44")
    assert result.__class__ is Allele, f'Expected parse("A*24:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_440():
    result = parse("A*24:440")
    assert result.__class__ is Allele, f'Expected parse("A*24:440") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:440") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_441():
    result = parse("A*24:441")
    assert result.__class__ is Allele, f'Expected parse("A*24:441") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:441") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_442():
    result = parse("A*24:442")
    assert result.__class__ is Allele, f'Expected parse("A*24:442") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:442") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_443():
    result = parse("A*24:443")
    assert result.__class__ is Allele, f'Expected parse("A*24:443") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:443") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_444():
    result = parse("A*24:444")
    assert result.__class__ is Allele, f'Expected parse("A*24:444") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:444") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_445N():
    result = parse("A*24:445N")
    assert result.__class__ is Allele, f'Expected parse("A*24:445N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:445N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_446():
    result = parse("A*24:446")
    assert result.__class__ is Allele, f'Expected parse("A*24:446") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:446") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_447Q():
    result = parse("A*24:447Q")
    assert result.__class__ is Allele, f'Expected parse("A*24:447Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:447Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_448N():
    result = parse("A*24:448N")
    assert result.__class__ is Allele, f'Expected parse("A*24:448N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:448N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_449():
    result = parse("A*24:449")
    assert result.__class__ is Allele, f'Expected parse("A*24:449") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:449") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_450Q():
    result = parse("A*24:450Q")
    assert result.__class__ is Allele, f'Expected parse("A*24:450Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:450Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_451():
    result = parse("A*24:451")
    assert result.__class__ is Allele, f'Expected parse("A*24:451") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:451") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_452():
    result = parse("A*24:452")
    assert result.__class__ is Allele, f'Expected parse("A*24:452") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:452") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_453():
    result = parse("A*24:453")
    assert result.__class__ is Allele, f'Expected parse("A*24:453") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:453") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_454():
    result = parse("A*24:454")
    assert result.__class__ is Allele, f'Expected parse("A*24:454") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:454") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_455():
    result = parse("A*24:455")
    assert result.__class__ is Allele, f'Expected parse("A*24:455") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:455") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_456N():
    result = parse("A*24:456N")
    assert result.__class__ is Allele, f'Expected parse("A*24:456N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:456N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_457():
    result = parse("A*24:457")
    assert result.__class__ is Allele, f'Expected parse("A*24:457") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:457") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_458():
    result = parse("A*24:458")
    assert result.__class__ is Allele, f'Expected parse("A*24:458") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:458") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_459():
    result = parse("A*24:459")
    assert result.__class__ is Allele, f'Expected parse("A*24:459") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:459") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_45N():
    result = parse("A*24:45N")
    assert result.__class__ is Allele, f'Expected parse("A*24:45N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:45N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_46():
    result = parse("A*24:46")
    assert result.__class__ is Allele, f'Expected parse("A*24:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_460():
    result = parse("A*24:460")
    assert result.__class__ is Allele, f'Expected parse("A*24:460") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:460") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_461():
    result = parse("A*24:461")
    assert result.__class__ is Allele, f'Expected parse("A*24:461") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:461") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_462():
    result = parse("A*24:462")
    assert result.__class__ is Allele, f'Expected parse("A*24:462") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:462") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_463():
    result = parse("A*24:463")
    assert result.__class__ is Allele, f'Expected parse("A*24:463") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:463") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_464():
    result = parse("A*24:464")
    assert result.__class__ is Allele, f'Expected parse("A*24:464") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:464") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_465():
    result = parse("A*24:465")
    assert result.__class__ is Allele, f'Expected parse("A*24:465") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:465") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_466():
    result = parse("A*24:466")
    assert result.__class__ is Allele, f'Expected parse("A*24:466") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:466") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_467N():
    result = parse("A*24:467N")
    assert result.__class__ is Allele, f'Expected parse("A*24:467N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:467N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_468():
    result = parse("A*24:468")
    assert result.__class__ is Allele, f'Expected parse("A*24:468") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:468") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_469():
    result = parse("A*24:469")
    assert result.__class__ is Allele, f'Expected parse("A*24:469") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:469") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_47():
    result = parse("A*24:47")
    assert result.__class__ is Allele, f'Expected parse("A*24:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_470():
    result = parse("A*24:470")
    assert result.__class__ is Allele, f'Expected parse("A*24:470") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:470") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_472():
    result = parse("A*24:472")
    assert result.__class__ is Allele, f'Expected parse("A*24:472") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:472") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_473Q():
    result = parse("A*24:473Q")
    assert result.__class__ is Allele, f'Expected parse("A*24:473Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:473Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_474():
    result = parse("A*24:474")
    assert result.__class__ is Allele, f'Expected parse("A*24:474") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:474") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_475():
    result = parse("A*24:475")
    assert result.__class__ is Allele, f'Expected parse("A*24:475") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:475") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_476():
    result = parse("A*24:476")
    assert result.__class__ is Allele, f'Expected parse("A*24:476") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:476") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_477():
    result = parse("A*24:477")
    assert result.__class__ is Allele, f'Expected parse("A*24:477") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:477") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_478():
    result = parse("A*24:478")
    assert result.__class__ is Allele, f'Expected parse("A*24:478") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:478") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_479Q():
    result = parse("A*24:479Q")
    assert result.__class__ is Allele, f'Expected parse("A*24:479Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:479Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_480():
    result = parse("A*24:480")
    assert result.__class__ is Allele, f'Expected parse("A*24:480") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:480") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_481():
    result = parse("A*24:481")
    assert result.__class__ is Allele, f'Expected parse("A*24:481") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:481") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_482():
    result = parse("A*24:482")
    assert result.__class__ is Allele, f'Expected parse("A*24:482") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:482") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_483():
    result = parse("A*24:483")
    assert result.__class__ is Allele, f'Expected parse("A*24:483") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:483") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_484():
    result = parse("A*24:484")
    assert result.__class__ is Allele, f'Expected parse("A*24:484") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:484") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_485():
    result = parse("A*24:485")
    assert result.__class__ is Allele, f'Expected parse("A*24:485") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:485") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_486():
    result = parse("A*24:486")
    assert result.__class__ is Allele, f'Expected parse("A*24:486") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:486") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_487():
    result = parse("A*24:487")
    assert result.__class__ is Allele, f'Expected parse("A*24:487") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:487") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_488():
    result = parse("A*24:488")
    assert result.__class__ is Allele, f'Expected parse("A*24:488") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:488") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_489():
    result = parse("A*24:489")
    assert result.__class__ is Allele, f'Expected parse("A*24:489") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:489") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_48N():
    result = parse("A*24:48N")
    assert result.__class__ is Allele, f'Expected parse("A*24:48N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:48N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_49():
    result = parse("A*24:49")
    assert result.__class__ is Allele, f'Expected parse("A*24:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_490():
    result = parse("A*24:490")
    assert result.__class__ is Allele, f'Expected parse("A*24:490") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:490") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_491():
    result = parse("A*24:491")
    assert result.__class__ is Allele, f'Expected parse("A*24:491") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:491") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_492():
    result = parse("A*24:492")
    assert result.__class__ is Allele, f'Expected parse("A*24:492") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:492") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_493():
    result = parse("A*24:493")
    assert result.__class__ is Allele, f'Expected parse("A*24:493") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:493") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_494():
    result = parse("A*24:494")
    assert result.__class__ is Allele, f'Expected parse("A*24:494") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:494") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_495():
    result = parse("A*24:495")
    assert result.__class__ is Allele, f'Expected parse("A*24:495") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:495") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_496():
    result = parse("A*24:496")
    assert result.__class__ is Allele, f'Expected parse("A*24:496") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:496") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_497():
    result = parse("A*24:497")
    assert result.__class__ is Allele, f'Expected parse("A*24:497") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:497") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_498():
    result = parse("A*24:498")
    assert result.__class__ is Allele, f'Expected parse("A*24:498") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:498") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_499():
    result = parse("A*24:499")
    assert result.__class__ is Allele, f'Expected parse("A*24:499") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:499") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_50():
    result = parse("A*24:50")
    assert result.__class__ is Allele, f'Expected parse("A*24:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_500():
    result = parse("A*24:500")
    assert result.__class__ is Allele, f'Expected parse("A*24:500") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:500") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_501():
    result = parse("A*24:501")
    assert result.__class__ is Allele, f'Expected parse("A*24:501") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:501") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_502():
    result = parse("A*24:502")
    assert result.__class__ is Allele, f'Expected parse("A*24:502") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:502") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_503():
    result = parse("A*24:503")
    assert result.__class__ is Allele, f'Expected parse("A*24:503") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:503") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_504():
    result = parse("A*24:504")
    assert result.__class__ is Allele, f'Expected parse("A*24:504") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:504") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_505():
    result = parse("A*24:505")
    assert result.__class__ is Allele, f'Expected parse("A*24:505") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:505") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_506():
    result = parse("A*24:506")
    assert result.__class__ is Allele, f'Expected parse("A*24:506") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:506") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_507():
    result = parse("A*24:507")
    assert result.__class__ is Allele, f'Expected parse("A*24:507") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:507") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_51():
    result = parse("A*24:51")
    assert result.__class__ is Allele, f'Expected parse("A*24:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_52():
    result = parse("A*24:52")
    assert result.__class__ is Allele, f'Expected parse("A*24:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_53():
    result = parse("A*24:53")
    assert result.__class__ is Allele, f'Expected parse("A*24:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_54():
    result = parse("A*24:54")
    assert result.__class__ is Allele, f'Expected parse("A*24:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_55():
    result = parse("A*24:55")
    assert result.__class__ is Allele, f'Expected parse("A*24:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_56():
    result = parse("A*24:56")
    assert result.__class__ is Allele, f'Expected parse("A*24:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_57():
    result = parse("A*24:57")
    assert result.__class__ is Allele, f'Expected parse("A*24:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_58():
    result = parse("A*24:58")
    assert result.__class__ is Allele, f'Expected parse("A*24:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_59():
    result = parse("A*24:59")
    assert result.__class__ is Allele, f'Expected parse("A*24:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_60N():
    result = parse("A*24:60N")
    assert result.__class__ is Allele, f'Expected parse("A*24:60N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:60N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_61():
    result = parse("A*24:61")
    assert result.__class__ is Allele, f'Expected parse("A*24:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_62():
    result = parse("A*24:62")
    assert result.__class__ is Allele, f'Expected parse("A*24:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_63():
    result = parse("A*24:63")
    assert result.__class__ is Allele, f'Expected parse("A*24:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_64():
    result = parse("A*24:64")
    assert result.__class__ is Allele, f'Expected parse("A*24:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_66():
    result = parse("A*24:66")
    assert result.__class__ is Allele, f'Expected parse("A*24:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_67():
    result = parse("A*24:67")
    assert result.__class__ is Allele, f'Expected parse("A*24:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_68():
    result = parse("A*24:68")
    assert result.__class__ is Allele, f'Expected parse("A*24:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_69():
    result = parse("A*24:69")
    assert result.__class__ is Allele, f'Expected parse("A*24:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_70():
    result = parse("A*24:70")
    assert result.__class__ is Allele, f'Expected parse("A*24:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_71():
    result = parse("A*24:71")
    assert result.__class__ is Allele, f'Expected parse("A*24:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_72():
    result = parse("A*24:72")
    assert result.__class__ is Allele, f'Expected parse("A*24:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_73():
    result = parse("A*24:73")
    assert result.__class__ is Allele, f'Expected parse("A*24:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_74_01():
    result = parse("A*24:74:01")
    assert result.__class__ is Allele, f'Expected parse("A*24:74:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:74:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_74_02():
    result = parse("A*24:74:02")
    assert result.__class__ is Allele, f'Expected parse("A*24:74:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:74:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_75():
    result = parse("A*24:75")
    assert result.__class__ is Allele, f'Expected parse("A*24:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_76():
    result = parse("A*24:76")
    assert result.__class__ is Allele, f'Expected parse("A*24:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_77():
    result = parse("A*24:77")
    assert result.__class__ is Allele, f'Expected parse("A*24:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_78():
    result = parse("A*24:78")
    assert result.__class__ is Allele, f'Expected parse("A*24:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_79():
    result = parse("A*24:79")
    assert result.__class__ is Allele, f'Expected parse("A*24:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_80():
    result = parse("A*24:80")
    assert result.__class__ is Allele, f'Expected parse("A*24:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_81():
    result = parse("A*24:81")
    assert result.__class__ is Allele, f'Expected parse("A*24:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_82():
    result = parse("A*24:82")
    assert result.__class__ is Allele, f'Expected parse("A*24:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_83N():
    result = parse("A*24:83N")
    assert result.__class__ is Allele, f'Expected parse("A*24:83N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:83N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_84N():
    result = parse("A*24:84N")
    assert result.__class__ is Allele, f'Expected parse("A*24:84N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:84N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_85():
    result = parse("A*24:85")
    assert result.__class__ is Allele, f'Expected parse("A*24:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_86N():
    result = parse("A*24:86N")
    assert result.__class__ is Allele, f'Expected parse("A*24:86N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:86N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_87():
    result = parse("A*24:87")
    assert result.__class__ is Allele, f'Expected parse("A*24:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_88():
    result = parse("A*24:88")
    assert result.__class__ is Allele, f'Expected parse("A*24:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_89():
    result = parse("A*24:89")
    assert result.__class__ is Allele, f'Expected parse("A*24:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_90_01N():
    result = parse("A*24:90:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:90:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:90:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_90_02N():
    result = parse("A*24:90:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*24:90:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*24:90:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_91():
    result = parse("A*24:91")
    assert result.__class__ is Allele, f'Expected parse("A*24:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_92():
    result = parse("A*24:92")
    assert result.__class__ is Allele, f'Expected parse("A*24:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_93():
    result = parse("A*24:93")
    assert result.__class__ is Allele, f'Expected parse("A*24:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_94():
    result = parse("A*24:94")
    assert result.__class__ is Allele, f'Expected parse("A*24:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_95():
    result = parse("A*24:95")
    assert result.__class__ is Allele, f'Expected parse("A*24:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_96():
    result = parse("A*24:96")
    assert result.__class__ is Allele, f'Expected parse("A*24:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_97():
    result = parse("A*24:97")
    assert result.__class__ is Allele, f'Expected parse("A*24:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_98():
    result = parse("A*24:98")
    assert result.__class__ is Allele, f'Expected parse("A*24:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_24_99():
    result = parse("A*24:99")
    assert result.__class__ is Allele, f'Expected parse("A*24:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*24:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_01_01():
    result = parse("A*25:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*25:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*25:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_01_02():
    result = parse("A*25:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*25:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*25:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_01_03():
    result = parse("A*25:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*25:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*25:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_01_04():
    result = parse("A*25:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*25:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*25:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_01_05():
    result = parse("A*25:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*25:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*25:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_01_06():
    result = parse("A*25:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*25:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*25:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_01_07():
    result = parse("A*25:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*25:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*25:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_02():
    result = parse("A*25:01:02")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_03():
    result = parse("A*25:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_04():
    result = parse("A*25:01:04")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_05():
    result = parse("A*25:01:05")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_06():
    result = parse("A*25:01:06")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_07():
    result = parse("A*25:01:07")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_08():
    result = parse("A*25:01:08")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_09():
    result = parse("A*25:01:09")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_10():
    result = parse("A*25:01:10")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_11():
    result = parse("A*25:01:11")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_12():
    result = parse("A*25:01:12")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_13():
    result = parse("A*25:01:13")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_14():
    result = parse("A*25:01:14")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_15():
    result = parse("A*25:01:15")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_16():
    result = parse("A*25:01:16")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_17():
    result = parse("A*25:01:17")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_18():
    result = parse("A*25:01:18")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_19():
    result = parse("A*25:01:19")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_01_20():
    result = parse("A*25:01:20")
    assert result.__class__ is Allele, f'Expected parse("A*25:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_02():
    result = parse("A*25:02")
    assert result.__class__ is Allele, f'Expected parse("A*25:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_03():
    result = parse("A*25:03")
    assert result.__class__ is Allele, f'Expected parse("A*25:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_04():
    result = parse("A*25:04")
    assert result.__class__ is Allele, f'Expected parse("A*25:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_05():
    result = parse("A*25:05")
    assert result.__class__ is Allele, f'Expected parse("A*25:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_06():
    result = parse("A*25:06")
    assert result.__class__ is Allele, f'Expected parse("A*25:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_07():
    result = parse("A*25:07")
    assert result.__class__ is Allele, f'Expected parse("A*25:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_08():
    result = parse("A*25:08")
    assert result.__class__ is Allele, f'Expected parse("A*25:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_09():
    result = parse("A*25:09")
    assert result.__class__ is Allele, f'Expected parse("A*25:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_10():
    result = parse("A*25:10")
    assert result.__class__ is Allele, f'Expected parse("A*25:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_11():
    result = parse("A*25:11")
    assert result.__class__ is Allele, f'Expected parse("A*25:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_12N():
    result = parse("A*25:12N")
    assert result.__class__ is Allele, f'Expected parse("A*25:12N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:12N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_13():
    result = parse("A*25:13")
    assert result.__class__ is Allele, f'Expected parse("A*25:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_14():
    result = parse("A*25:14")
    assert result.__class__ is Allele, f'Expected parse("A*25:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_15():
    result = parse("A*25:15")
    assert result.__class__ is Allele, f'Expected parse("A*25:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_16():
    result = parse("A*25:16")
    assert result.__class__ is Allele, f'Expected parse("A*25:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_17():
    result = parse("A*25:17")
    assert result.__class__ is Allele, f'Expected parse("A*25:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_18():
    result = parse("A*25:18")
    assert result.__class__ is Allele, f'Expected parse("A*25:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_19_01():
    result = parse("A*25:19:01")
    assert result.__class__ is Allele, f'Expected parse("A*25:19:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:19:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_19_02():
    result = parse("A*25:19:02")
    assert result.__class__ is Allele, f'Expected parse("A*25:19:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:19:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_20():
    result = parse("A*25:20")
    assert result.__class__ is Allele, f'Expected parse("A*25:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_21():
    result = parse("A*25:21")
    assert result.__class__ is Allele, f'Expected parse("A*25:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_22():
    result = parse("A*25:22")
    assert result.__class__ is Allele, f'Expected parse("A*25:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_23():
    result = parse("A*25:23")
    assert result.__class__ is Allele, f'Expected parse("A*25:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_24():
    result = parse("A*25:24")
    assert result.__class__ is Allele, f'Expected parse("A*25:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_25():
    result = parse("A*25:25")
    assert result.__class__ is Allele, f'Expected parse("A*25:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_26():
    result = parse("A*25:26")
    assert result.__class__ is Allele, f'Expected parse("A*25:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_27_01():
    result = parse("A*25:27:01")
    assert result.__class__ is Allele, f'Expected parse("A*25:27:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:27:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_27_02():
    result = parse("A*25:27:02")
    assert result.__class__ is Allele, f'Expected parse("A*25:27:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*25:27:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_28():
    result = parse("A*25:28")
    assert result.__class__ is Allele, f'Expected parse("A*25:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_29():
    result = parse("A*25:29")
    assert result.__class__ is Allele, f'Expected parse("A*25:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_30():
    result = parse("A*25:30")
    assert result.__class__ is Allele, f'Expected parse("A*25:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_31():
    result = parse("A*25:31")
    assert result.__class__ is Allele, f'Expected parse("A*25:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_32():
    result = parse("A*25:32")
    assert result.__class__ is Allele, f'Expected parse("A*25:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_33():
    result = parse("A*25:33")
    assert result.__class__ is Allele, f'Expected parse("A*25:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_34():
    result = parse("A*25:34")
    assert result.__class__ is Allele, f'Expected parse("A*25:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_35():
    result = parse("A*25:35")
    assert result.__class__ is Allele, f'Expected parse("A*25:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_36():
    result = parse("A*25:36")
    assert result.__class__ is Allele, f'Expected parse("A*25:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_37():
    result = parse("A*25:37")
    assert result.__class__ is Allele, f'Expected parse("A*25:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_38():
    result = parse("A*25:38")
    assert result.__class__ is Allele, f'Expected parse("A*25:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_39():
    result = parse("A*25:39")
    assert result.__class__ is Allele, f'Expected parse("A*25:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_40():
    result = parse("A*25:40")
    assert result.__class__ is Allele, f'Expected parse("A*25:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_41():
    result = parse("A*25:41")
    assert result.__class__ is Allele, f'Expected parse("A*25:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_42N():
    result = parse("A*25:42N")
    assert result.__class__ is Allele, f'Expected parse("A*25:42N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:42N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_43():
    result = parse("A*25:43")
    assert result.__class__ is Allele, f'Expected parse("A*25:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_44():
    result = parse("A*25:44")
    assert result.__class__ is Allele, f'Expected parse("A*25:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_45():
    result = parse("A*25:45")
    assert result.__class__ is Allele, f'Expected parse("A*25:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_46():
    result = parse("A*25:46")
    assert result.__class__ is Allele, f'Expected parse("A*25:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_47():
    result = parse("A*25:47")
    assert result.__class__ is Allele, f'Expected parse("A*25:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_48():
    result = parse("A*25:48")
    assert result.__class__ is Allele, f'Expected parse("A*25:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_49N():
    result = parse("A*25:49N")
    assert result.__class__ is Allele, f'Expected parse("A*25:49N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:49N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_50():
    result = parse("A*25:50")
    assert result.__class__ is Allele, f'Expected parse("A*25:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_51():
    result = parse("A*25:51")
    assert result.__class__ is Allele, f'Expected parse("A*25:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_52():
    result = parse("A*25:52")
    assert result.__class__ is Allele, f'Expected parse("A*25:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_53():
    result = parse("A*25:53")
    assert result.__class__ is Allele, f'Expected parse("A*25:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_54():
    result = parse("A*25:54")
    assert result.__class__ is Allele, f'Expected parse("A*25:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_55():
    result = parse("A*25:55")
    assert result.__class__ is Allele, f'Expected parse("A*25:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_56():
    result = parse("A*25:56")
    assert result.__class__ is Allele, f'Expected parse("A*25:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_57():
    result = parse("A*25:57")
    assert result.__class__ is Allele, f'Expected parse("A*25:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_58():
    result = parse("A*25:58")
    assert result.__class__ is Allele, f'Expected parse("A*25:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_59():
    result = parse("A*25:59")
    assert result.__class__ is Allele, f'Expected parse("A*25:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_60():
    result = parse("A*25:60")
    assert result.__class__ is Allele, f'Expected parse("A*25:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_61():
    result = parse("A*25:61")
    assert result.__class__ is Allele, f'Expected parse("A*25:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_62():
    result = parse("A*25:62")
    assert result.__class__ is Allele, f'Expected parse("A*25:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_63():
    result = parse("A*25:63")
    assert result.__class__ is Allele, f'Expected parse("A*25:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_64():
    result = parse("A*25:64")
    assert result.__class__ is Allele, f'Expected parse("A*25:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_65():
    result = parse("A*25:65")
    assert result.__class__ is Allele, f'Expected parse("A*25:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_66():
    result = parse("A*25:66")
    assert result.__class__ is Allele, f'Expected parse("A*25:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_67():
    result = parse("A*25:67")
    assert result.__class__ is Allele, f'Expected parse("A*25:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_25_68():
    result = parse("A*25:68")
    assert result.__class__ is Allele, f'Expected parse("A*25:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*25:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_01():
    result = parse("A*26:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_02():
    result = parse("A*26:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_03N():
    result = parse("A*26:01:01:03N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:03N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:03N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_04():
    result = parse("A*26:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_05():
    result = parse("A*26:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_06():
    result = parse("A*26:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_07():
    result = parse("A*26:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_08():
    result = parse("A*26:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_09():
    result = parse("A*26:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_10():
    result = parse("A*26:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_11():
    result = parse("A*26:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_12():
    result = parse("A*26:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_13():
    result = parse("A*26:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_14():
    result = parse("A*26:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_15():
    result = parse("A*26:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_16():
    result = parse("A*26:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_17():
    result = parse("A*26:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_18():
    result = parse("A*26:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_19():
    result = parse("A*26:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_20():
    result = parse("A*26:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_21():
    result = parse("A*26:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_22():
    result = parse("A*26:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_23():
    result = parse("A*26:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_24():
    result = parse("A*26:01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_25():
    result = parse("A*26:01:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_26():
    result = parse("A*26:01:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_27():
    result = parse("A*26:01:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_28():
    result = parse("A*26:01:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_29():
    result = parse("A*26:01:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_30():
    result = parse("A*26:01:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_31():
    result = parse("A*26:01:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_32():
    result = parse("A*26:01:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_33():
    result = parse("A*26:01:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_34():
    result = parse("A*26:01:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_01_35():
    result = parse("A*26:01:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:01:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:01:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_02():
    result = parse("A*26:01:02")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_03():
    result = parse("A*26:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_04():
    result = parse("A*26:01:04")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_05():
    result = parse("A*26:01:05")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_06():
    result = parse("A*26:01:06")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_07():
    result = parse("A*26:01:07")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_08():
    result = parse("A*26:01:08")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_09():
    result = parse("A*26:01:09")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_10():
    result = parse("A*26:01:10")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_11():
    result = parse("A*26:01:11")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_12():
    result = parse("A*26:01:12")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_13():
    result = parse("A*26:01:13")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_14():
    result = parse("A*26:01:14")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_15():
    result = parse("A*26:01:15")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_16():
    result = parse("A*26:01:16")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_17():
    result = parse("A*26:01:17")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_18():
    result = parse("A*26:01:18")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_19():
    result = parse("A*26:01:19")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_20():
    result = parse("A*26:01:20")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_21():
    result = parse("A*26:01:21")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_22():
    result = parse("A*26:01:22")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_23():
    result = parse("A*26:01:23")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_24():
    result = parse("A*26:01:24")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_25():
    result = parse("A*26:01:25")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_26():
    result = parse("A*26:01:26")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_27():
    result = parse("A*26:01:27")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_28():
    result = parse("A*26:01:28")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_29():
    result = parse("A*26:01:29")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_30():
    result = parse("A*26:01:30")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_31():
    result = parse("A*26:01:31")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_32():
    result = parse("A*26:01:32")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_33():
    result = parse("A*26:01:33")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_34():
    result = parse("A*26:01:34")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_35():
    result = parse("A*26:01:35")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_36():
    result = parse("A*26:01:36")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_37():
    result = parse("A*26:01:37")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_38():
    result = parse("A*26:01:38")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_39():
    result = parse("A*26:01:39")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_40():
    result = parse("A*26:01:40")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_41():
    result = parse("A*26:01:41")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_42():
    result = parse("A*26:01:42")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_43():
    result = parse("A*26:01:43")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_44():
    result = parse("A*26:01:44")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_45():
    result = parse("A*26:01:45")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_46():
    result = parse("A*26:01:46")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_47():
    result = parse("A*26:01:47")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_48():
    result = parse("A*26:01:48")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_49():
    result = parse("A*26:01:49")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_50():
    result = parse("A*26:01:50")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_51():
    result = parse("A*26:01:51")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_52():
    result = parse("A*26:01:52")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_53():
    result = parse("A*26:01:53")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_54():
    result = parse("A*26:01:54")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_55():
    result = parse("A*26:01:55")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_56():
    result = parse("A*26:01:56")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_57():
    result = parse("A*26:01:57")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_58():
    result = parse("A*26:01:58")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_59():
    result = parse("A*26:01:59")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_60():
    result = parse("A*26:01:60")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_61():
    result = parse("A*26:01:61")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_62():
    result = parse("A*26:01:62")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_63():
    result = parse("A*26:01:63")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_64():
    result = parse("A*26:01:64")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_01_65():
    result = parse("A*26:01:65")
    assert result.__class__ is Allele, f'Expected parse("A*26:01:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:01:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_02_01():
    result = parse("A*26:02:01")
    assert result.__class__ is Allele, f'Expected parse("A*26:02:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_02_02():
    result = parse("A*26:02:02")
    assert result.__class__ is Allele, f'Expected parse("A*26:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_03_01_01():
    result = parse("A*26:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_03_01_02():
    result = parse("A*26:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_04():
    result = parse("A*26:04")
    assert result.__class__ is Allele, f'Expected parse("A*26:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_05():
    result = parse("A*26:05")
    assert result.__class__ is Allele, f'Expected parse("A*26:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_06():
    result = parse("A*26:06")
    assert result.__class__ is Allele, f'Expected parse("A*26:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_07_01():
    result = parse("A*26:07:01")
    assert result.__class__ is Allele, f'Expected parse("A*26:07:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_07_02():
    result = parse("A*26:07:02")
    assert result.__class__ is Allele, f'Expected parse("A*26:07:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_08_01_01():
    result = parse("A*26:08:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:08:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:08:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_08_01_02():
    result = parse("A*26:08:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*26:08:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*26:08:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_08_02():
    result = parse("A*26:08:02")
    assert result.__class__ is Allele, f'Expected parse("A*26:08:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:08:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_08_03():
    result = parse("A*26:08:03")
    assert result.__class__ is Allele, f'Expected parse("A*26:08:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:08:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_09():
    result = parse("A*26:09")
    assert result.__class__ is Allele, f'Expected parse("A*26:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_10():
    result = parse("A*26:10")
    assert result.__class__ is Allele, f'Expected parse("A*26:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_100():
    result = parse("A*26:100")
    assert result.__class__ is Allele, f'Expected parse("A*26:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_101():
    result = parse("A*26:101")
    assert result.__class__ is Allele, f'Expected parse("A*26:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_102():
    result = parse("A*26:102")
    assert result.__class__ is Allele, f'Expected parse("A*26:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_103():
    result = parse("A*26:103")
    assert result.__class__ is Allele, f'Expected parse("A*26:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_104():
    result = parse("A*26:104")
    assert result.__class__ is Allele, f'Expected parse("A*26:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_105():
    result = parse("A*26:105")
    assert result.__class__ is Allele, f'Expected parse("A*26:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_106():
    result = parse("A*26:106")
    assert result.__class__ is Allele, f'Expected parse("A*26:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_107N():
    result = parse("A*26:107N")
    assert result.__class__ is Allele, f'Expected parse("A*26:107N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:107N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_108():
    result = parse("A*26:108")
    assert result.__class__ is Allele, f'Expected parse("A*26:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_109():
    result = parse("A*26:109")
    assert result.__class__ is Allele, f'Expected parse("A*26:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_110():
    result = parse("A*26:110")
    assert result.__class__ is Allele, f'Expected parse("A*26:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_111():
    result = parse("A*26:111")
    assert result.__class__ is Allele, f'Expected parse("A*26:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_112():
    result = parse("A*26:112")
    assert result.__class__ is Allele, f'Expected parse("A*26:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_113():
    result = parse("A*26:113")
    assert result.__class__ is Allele, f'Expected parse("A*26:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_114():
    result = parse("A*26:114")
    assert result.__class__ is Allele, f'Expected parse("A*26:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_115():
    result = parse("A*26:115")
    assert result.__class__ is Allele, f'Expected parse("A*26:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_116():
    result = parse("A*26:116")
    assert result.__class__ is Allele, f'Expected parse("A*26:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_117():
    result = parse("A*26:117")
    assert result.__class__ is Allele, f'Expected parse("A*26:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_118():
    result = parse("A*26:118")
    assert result.__class__ is Allele, f'Expected parse("A*26:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_119():
    result = parse("A*26:119")
    assert result.__class__ is Allele, f'Expected parse("A*26:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_11N():
    result = parse("A*26:11N")
    assert result.__class__ is Allele, f'Expected parse("A*26:11N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:11N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_12():
    result = parse("A*26:12")
    assert result.__class__ is Allele, f'Expected parse("A*26:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_120():
    result = parse("A*26:120")
    assert result.__class__ is Allele, f'Expected parse("A*26:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_121():
    result = parse("A*26:121")
    assert result.__class__ is Allele, f'Expected parse("A*26:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_122():
    result = parse("A*26:122")
    assert result.__class__ is Allele, f'Expected parse("A*26:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_123():
    result = parse("A*26:123")
    assert result.__class__ is Allele, f'Expected parse("A*26:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_124():
    result = parse("A*26:124")
    assert result.__class__ is Allele, f'Expected parse("A*26:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_125():
    result = parse("A*26:125")
    assert result.__class__ is Allele, f'Expected parse("A*26:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_126():
    result = parse("A*26:126")
    assert result.__class__ is Allele, f'Expected parse("A*26:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_127N():
    result = parse("A*26:127N")
    assert result.__class__ is Allele, f'Expected parse("A*26:127N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:127N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_128():
    result = parse("A*26:128")
    assert result.__class__ is Allele, f'Expected parse("A*26:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_129():
    result = parse("A*26:129")
    assert result.__class__ is Allele, f'Expected parse("A*26:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_13():
    result = parse("A*26:13")
    assert result.__class__ is Allele, f'Expected parse("A*26:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_130():
    result = parse("A*26:130")
    assert result.__class__ is Allele, f'Expected parse("A*26:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_131():
    result = parse("A*26:131")
    assert result.__class__ is Allele, f'Expected parse("A*26:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_132():
    result = parse("A*26:132")
    assert result.__class__ is Allele, f'Expected parse("A*26:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_133():
    result = parse("A*26:133")
    assert result.__class__ is Allele, f'Expected parse("A*26:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_134():
    result = parse("A*26:134")
    assert result.__class__ is Allele, f'Expected parse("A*26:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_135():
    result = parse("A*26:135")
    assert result.__class__ is Allele, f'Expected parse("A*26:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_136():
    result = parse("A*26:136")
    assert result.__class__ is Allele, f'Expected parse("A*26:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_137():
    result = parse("A*26:137")
    assert result.__class__ is Allele, f'Expected parse("A*26:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_138():
    result = parse("A*26:138")
    assert result.__class__ is Allele, f'Expected parse("A*26:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_139():
    result = parse("A*26:139")
    assert result.__class__ is Allele, f'Expected parse("A*26:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_14():
    result = parse("A*26:14")
    assert result.__class__ is Allele, f'Expected parse("A*26:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_140():
    result = parse("A*26:140")
    assert result.__class__ is Allele, f'Expected parse("A*26:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_141():
    result = parse("A*26:141")
    assert result.__class__ is Allele, f'Expected parse("A*26:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_142():
    result = parse("A*26:142")
    assert result.__class__ is Allele, f'Expected parse("A*26:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_143():
    result = parse("A*26:143")
    assert result.__class__ is Allele, f'Expected parse("A*26:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_144():
    result = parse("A*26:144")
    assert result.__class__ is Allele, f'Expected parse("A*26:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_145N():
    result = parse("A*26:145N")
    assert result.__class__ is Allele, f'Expected parse("A*26:145N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:145N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_146():
    result = parse("A*26:146")
    assert result.__class__ is Allele, f'Expected parse("A*26:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_147():
    result = parse("A*26:147")
    assert result.__class__ is Allele, f'Expected parse("A*26:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_148():
    result = parse("A*26:148")
    assert result.__class__ is Allele, f'Expected parse("A*26:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_149():
    result = parse("A*26:149")
    assert result.__class__ is Allele, f'Expected parse("A*26:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_15():
    result = parse("A*26:15")
    assert result.__class__ is Allele, f'Expected parse("A*26:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_150():
    result = parse("A*26:150")
    assert result.__class__ is Allele, f'Expected parse("A*26:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_151():
    result = parse("A*26:151")
    assert result.__class__ is Allele, f'Expected parse("A*26:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_152():
    result = parse("A*26:152")
    assert result.__class__ is Allele, f'Expected parse("A*26:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_153():
    result = parse("A*26:153")
    assert result.__class__ is Allele, f'Expected parse("A*26:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_154():
    result = parse("A*26:154")
    assert result.__class__ is Allele, f'Expected parse("A*26:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_155():
    result = parse("A*26:155")
    assert result.__class__ is Allele, f'Expected parse("A*26:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_156():
    result = parse("A*26:156")
    assert result.__class__ is Allele, f'Expected parse("A*26:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_157():
    result = parse("A*26:157")
    assert result.__class__ is Allele, f'Expected parse("A*26:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_158():
    result = parse("A*26:158")
    assert result.__class__ is Allele, f'Expected parse("A*26:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_159():
    result = parse("A*26:159")
    assert result.__class__ is Allele, f'Expected parse("A*26:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_16():
    result = parse("A*26:16")
    assert result.__class__ is Allele, f'Expected parse("A*26:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_160():
    result = parse("A*26:160")
    assert result.__class__ is Allele, f'Expected parse("A*26:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_161N():
    result = parse("A*26:161N")
    assert result.__class__ is Allele, f'Expected parse("A*26:161N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:161N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_162():
    result = parse("A*26:162")
    assert result.__class__ is Allele, f'Expected parse("A*26:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_163():
    result = parse("A*26:163")
    assert result.__class__ is Allele, f'Expected parse("A*26:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_164():
    result = parse("A*26:164")
    assert result.__class__ is Allele, f'Expected parse("A*26:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_165():
    result = parse("A*26:165")
    assert result.__class__ is Allele, f'Expected parse("A*26:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_166Q():
    result = parse("A*26:166Q")
    assert result.__class__ is Allele, f'Expected parse("A*26:166Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:166Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_167():
    result = parse("A*26:167")
    assert result.__class__ is Allele, f'Expected parse("A*26:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_168():
    result = parse("A*26:168")
    assert result.__class__ is Allele, f'Expected parse("A*26:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_169():
    result = parse("A*26:169")
    assert result.__class__ is Allele, f'Expected parse("A*26:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_17():
    result = parse("A*26:17")
    assert result.__class__ is Allele, f'Expected parse("A*26:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_170():
    result = parse("A*26:170")
    assert result.__class__ is Allele, f'Expected parse("A*26:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_171():
    result = parse("A*26:171")
    assert result.__class__ is Allele, f'Expected parse("A*26:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_172():
    result = parse("A*26:172")
    assert result.__class__ is Allele, f'Expected parse("A*26:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_173():
    result = parse("A*26:173")
    assert result.__class__ is Allele, f'Expected parse("A*26:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_174():
    result = parse("A*26:174")
    assert result.__class__ is Allele, f'Expected parse("A*26:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_175():
    result = parse("A*26:175")
    assert result.__class__ is Allele, f'Expected parse("A*26:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_176():
    result = parse("A*26:176")
    assert result.__class__ is Allele, f'Expected parse("A*26:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_177():
    result = parse("A*26:177")
    assert result.__class__ is Allele, f'Expected parse("A*26:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_178():
    result = parse("A*26:178")
    assert result.__class__ is Allele, f'Expected parse("A*26:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_179():
    result = parse("A*26:179")
    assert result.__class__ is Allele, f'Expected parse("A*26:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_18():
    result = parse("A*26:18")
    assert result.__class__ is Allele, f'Expected parse("A*26:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_180N():
    result = parse("A*26:180N")
    assert result.__class__ is Allele, f'Expected parse("A*26:180N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:180N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_181():
    result = parse("A*26:181")
    assert result.__class__ is Allele, f'Expected parse("A*26:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_182():
    result = parse("A*26:182")
    assert result.__class__ is Allele, f'Expected parse("A*26:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_183():
    result = parse("A*26:183")
    assert result.__class__ is Allele, f'Expected parse("A*26:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_184():
    result = parse("A*26:184")
    assert result.__class__ is Allele, f'Expected parse("A*26:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_185():
    result = parse("A*26:185")
    assert result.__class__ is Allele, f'Expected parse("A*26:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_186():
    result = parse("A*26:186")
    assert result.__class__ is Allele, f'Expected parse("A*26:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_187():
    result = parse("A*26:187")
    assert result.__class__ is Allele, f'Expected parse("A*26:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_188():
    result = parse("A*26:188")
    assert result.__class__ is Allele, f'Expected parse("A*26:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_189():
    result = parse("A*26:189")
    assert result.__class__ is Allele, f'Expected parse("A*26:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_19():
    result = parse("A*26:19")
    assert result.__class__ is Allele, f'Expected parse("A*26:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_190():
    result = parse("A*26:190")
    assert result.__class__ is Allele, f'Expected parse("A*26:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_191N():
    result = parse("A*26:191N")
    assert result.__class__ is Allele, f'Expected parse("A*26:191N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:191N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_192():
    result = parse("A*26:192")
    assert result.__class__ is Allele, f'Expected parse("A*26:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_193():
    result = parse("A*26:193")
    assert result.__class__ is Allele, f'Expected parse("A*26:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_194():
    result = parse("A*26:194")
    assert result.__class__ is Allele, f'Expected parse("A*26:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_195():
    result = parse("A*26:195")
    assert result.__class__ is Allele, f'Expected parse("A*26:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_196():
    result = parse("A*26:196")
    assert result.__class__ is Allele, f'Expected parse("A*26:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_197():
    result = parse("A*26:197")
    assert result.__class__ is Allele, f'Expected parse("A*26:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_198():
    result = parse("A*26:198")
    assert result.__class__ is Allele, f'Expected parse("A*26:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_199():
    result = parse("A*26:199")
    assert result.__class__ is Allele, f'Expected parse("A*26:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_20():
    result = parse("A*26:20")
    assert result.__class__ is Allele, f'Expected parse("A*26:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_200():
    result = parse("A*26:200")
    assert result.__class__ is Allele, f'Expected parse("A*26:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_201():
    result = parse("A*26:201")
    assert result.__class__ is Allele, f'Expected parse("A*26:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_202N():
    result = parse("A*26:202N")
    assert result.__class__ is Allele, f'Expected parse("A*26:202N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:202N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_203():
    result = parse("A*26:203")
    assert result.__class__ is Allele, f'Expected parse("A*26:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_204():
    result = parse("A*26:204")
    assert result.__class__ is Allele, f'Expected parse("A*26:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_205():
    result = parse("A*26:205")
    assert result.__class__ is Allele, f'Expected parse("A*26:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_21():
    result = parse("A*26:21")
    assert result.__class__ is Allele, f'Expected parse("A*26:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_22():
    result = parse("A*26:22")
    assert result.__class__ is Allele, f'Expected parse("A*26:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_23():
    result = parse("A*26:23")
    assert result.__class__ is Allele, f'Expected parse("A*26:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_24():
    result = parse("A*26:24")
    assert result.__class__ is Allele, f'Expected parse("A*26:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_25N():
    result = parse("A*26:25N")
    assert result.__class__ is Allele, f'Expected parse("A*26:25N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:25N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_26():
    result = parse("A*26:26")
    assert result.__class__ is Allele, f'Expected parse("A*26:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_27():
    result = parse("A*26:27")
    assert result.__class__ is Allele, f'Expected parse("A*26:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_28():
    result = parse("A*26:28")
    assert result.__class__ is Allele, f'Expected parse("A*26:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_29():
    result = parse("A*26:29")
    assert result.__class__ is Allele, f'Expected parse("A*26:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_30():
    result = parse("A*26:30")
    assert result.__class__ is Allele, f'Expected parse("A*26:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_31():
    result = parse("A*26:31")
    assert result.__class__ is Allele, f'Expected parse("A*26:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_32():
    result = parse("A*26:32")
    assert result.__class__ is Allele, f'Expected parse("A*26:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_33():
    result = parse("A*26:33")
    assert result.__class__ is Allele, f'Expected parse("A*26:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_34():
    result = parse("A*26:34")
    assert result.__class__ is Allele, f'Expected parse("A*26:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_35():
    result = parse("A*26:35")
    assert result.__class__ is Allele, f'Expected parse("A*26:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_36():
    result = parse("A*26:36")
    assert result.__class__ is Allele, f'Expected parse("A*26:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_37():
    result = parse("A*26:37")
    assert result.__class__ is Allele, f'Expected parse("A*26:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_38():
    result = parse("A*26:38")
    assert result.__class__ is Allele, f'Expected parse("A*26:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_39():
    result = parse("A*26:39")
    assert result.__class__ is Allele, f'Expected parse("A*26:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_40():
    result = parse("A*26:40")
    assert result.__class__ is Allele, f'Expected parse("A*26:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_41():
    result = parse("A*26:41")
    assert result.__class__ is Allele, f'Expected parse("A*26:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_42():
    result = parse("A*26:42")
    assert result.__class__ is Allele, f'Expected parse("A*26:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_43_01():
    result = parse("A*26:43:01")
    assert result.__class__ is Allele, f'Expected parse("A*26:43:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:43:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_43_02():
    result = parse("A*26:43:02")
    assert result.__class__ is Allele, f'Expected parse("A*26:43:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*26:43:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_45():
    result = parse("A*26:45")
    assert result.__class__ is Allele, f'Expected parse("A*26:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_46():
    result = parse("A*26:46")
    assert result.__class__ is Allele, f'Expected parse("A*26:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_47():
    result = parse("A*26:47")
    assert result.__class__ is Allele, f'Expected parse("A*26:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_48():
    result = parse("A*26:48")
    assert result.__class__ is Allele, f'Expected parse("A*26:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_49():
    result = parse("A*26:49")
    assert result.__class__ is Allele, f'Expected parse("A*26:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_50():
    result = parse("A*26:50")
    assert result.__class__ is Allele, f'Expected parse("A*26:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_51():
    result = parse("A*26:51")
    assert result.__class__ is Allele, f'Expected parse("A*26:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_52():
    result = parse("A*26:52")
    assert result.__class__ is Allele, f'Expected parse("A*26:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_53():
    result = parse("A*26:53")
    assert result.__class__ is Allele, f'Expected parse("A*26:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_54():
    result = parse("A*26:54")
    assert result.__class__ is Allele, f'Expected parse("A*26:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_55():
    result = parse("A*26:55")
    assert result.__class__ is Allele, f'Expected parse("A*26:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_56():
    result = parse("A*26:56")
    assert result.__class__ is Allele, f'Expected parse("A*26:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_57():
    result = parse("A*26:57")
    assert result.__class__ is Allele, f'Expected parse("A*26:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_58():
    result = parse("A*26:58")
    assert result.__class__ is Allele, f'Expected parse("A*26:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_59():
    result = parse("A*26:59")
    assert result.__class__ is Allele, f'Expected parse("A*26:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_60N():
    result = parse("A*26:60N")
    assert result.__class__ is Allele, f'Expected parse("A*26:60N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:60N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_61():
    result = parse("A*26:61")
    assert result.__class__ is Allele, f'Expected parse("A*26:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_62():
    result = parse("A*26:62")
    assert result.__class__ is Allele, f'Expected parse("A*26:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_63():
    result = parse("A*26:63")
    assert result.__class__ is Allele, f'Expected parse("A*26:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_64():
    result = parse("A*26:64")
    assert result.__class__ is Allele, f'Expected parse("A*26:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_65():
    result = parse("A*26:65")
    assert result.__class__ is Allele, f'Expected parse("A*26:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_66():
    result = parse("A*26:66")
    assert result.__class__ is Allele, f'Expected parse("A*26:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_67():
    result = parse("A*26:67")
    assert result.__class__ is Allele, f'Expected parse("A*26:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_68():
    result = parse("A*26:68")
    assert result.__class__ is Allele, f'Expected parse("A*26:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_69():
    result = parse("A*26:69")
    assert result.__class__ is Allele, f'Expected parse("A*26:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_70():
    result = parse("A*26:70")
    assert result.__class__ is Allele, f'Expected parse("A*26:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_71N():
    result = parse("A*26:71N")
    assert result.__class__ is Allele, f'Expected parse("A*26:71N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:71N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_72():
    result = parse("A*26:72")
    assert result.__class__ is Allele, f'Expected parse("A*26:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_73():
    result = parse("A*26:73")
    assert result.__class__ is Allele, f'Expected parse("A*26:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_74():
    result = parse("A*26:74")
    assert result.__class__ is Allele, f'Expected parse("A*26:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_75():
    result = parse("A*26:75")
    assert result.__class__ is Allele, f'Expected parse("A*26:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_76():
    result = parse("A*26:76")
    assert result.__class__ is Allele, f'Expected parse("A*26:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_77():
    result = parse("A*26:77")
    assert result.__class__ is Allele, f'Expected parse("A*26:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_78():
    result = parse("A*26:78")
    assert result.__class__ is Allele, f'Expected parse("A*26:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_79():
    result = parse("A*26:79")
    assert result.__class__ is Allele, f'Expected parse("A*26:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_80():
    result = parse("A*26:80")
    assert result.__class__ is Allele, f'Expected parse("A*26:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_81():
    result = parse("A*26:81")
    assert result.__class__ is Allele, f'Expected parse("A*26:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_82():
    result = parse("A*26:82")
    assert result.__class__ is Allele, f'Expected parse("A*26:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_83():
    result = parse("A*26:83")
    assert result.__class__ is Allele, f'Expected parse("A*26:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_84():
    result = parse("A*26:84")
    assert result.__class__ is Allele, f'Expected parse("A*26:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_85():
    result = parse("A*26:85")
    assert result.__class__ is Allele, f'Expected parse("A*26:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_86():
    result = parse("A*26:86")
    assert result.__class__ is Allele, f'Expected parse("A*26:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_87():
    result = parse("A*26:87")
    assert result.__class__ is Allele, f'Expected parse("A*26:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_88():
    result = parse("A*26:88")
    assert result.__class__ is Allele, f'Expected parse("A*26:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_89():
    result = parse("A*26:89")
    assert result.__class__ is Allele, f'Expected parse("A*26:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_90():
    result = parse("A*26:90")
    assert result.__class__ is Allele, f'Expected parse("A*26:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_91():
    result = parse("A*26:91")
    assert result.__class__ is Allele, f'Expected parse("A*26:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_92():
    result = parse("A*26:92")
    assert result.__class__ is Allele, f'Expected parse("A*26:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_93():
    result = parse("A*26:93")
    assert result.__class__ is Allele, f'Expected parse("A*26:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_94():
    result = parse("A*26:94")
    assert result.__class__ is Allele, f'Expected parse("A*26:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_95():
    result = parse("A*26:95")
    assert result.__class__ is Allele, f'Expected parse("A*26:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_96():
    result = parse("A*26:96")
    assert result.__class__ is Allele, f'Expected parse("A*26:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_97():
    result = parse("A*26:97")
    assert result.__class__ is Allele, f'Expected parse("A*26:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_98():
    result = parse("A*26:98")
    assert result.__class__ is Allele, f'Expected parse("A*26:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_26_99():
    result = parse("A*26:99")
    assert result.__class__ is Allele, f'Expected parse("A*26:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*26:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_01_01():
    result = parse("A*29:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_01_02N():
    result = parse("A*29:01:01:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:01:01:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:01:01:02N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_01_03():
    result = parse("A*29:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_01_04():
    result = parse("A*29:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_01_05():
    result = parse("A*29:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_01_06():
    result = parse("A*29:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_01_07():
    result = parse("A*29:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_02():
    result = parse("A*29:01:02")
    assert result.__class__ is Allele, f'Expected parse("A*29:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_03():
    result = parse("A*29:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*29:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_04():
    result = parse("A*29:01:04")
    assert result.__class__ is Allele, f'Expected parse("A*29:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_05():
    result = parse("A*29:01:05")
    assert result.__class__ is Allele, f'Expected parse("A*29:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_06():
    result = parse("A*29:01:06")
    assert result.__class__ is Allele, f'Expected parse("A*29:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_07():
    result = parse("A*29:01:07")
    assert result.__class__ is Allele, f'Expected parse("A*29:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_08():
    result = parse("A*29:01:08")
    assert result.__class__ is Allele, f'Expected parse("A*29:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_09():
    result = parse("A*29:01:09")
    assert result.__class__ is Allele, f'Expected parse("A*29:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_10():
    result = parse("A*29:01:10")
    assert result.__class__ is Allele, f'Expected parse("A*29:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_11():
    result = parse("A*29:01:11")
    assert result.__class__ is Allele, f'Expected parse("A*29:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_12():
    result = parse("A*29:01:12")
    assert result.__class__ is Allele, f'Expected parse("A*29:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_01_13():
    result = parse("A*29:01:13")
    assert result.__class__ is Allele, f'Expected parse("A*29:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_01():
    result = parse("A*29:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_02():
    result = parse("A*29:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_03():
    result = parse("A*29:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_04():
    result = parse("A*29:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_05():
    result = parse("A*29:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_06():
    result = parse("A*29:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_07():
    result = parse("A*29:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_08():
    result = parse("A*29:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_09():
    result = parse("A*29:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_10():
    result = parse("A*29:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_11():
    result = parse("A*29:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_12():
    result = parse("A*29:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_13():
    result = parse("A*29:02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_14():
    result = parse("A*29:02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_15():
    result = parse("A*29:02:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_16():
    result = parse("A*29:02:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_17():
    result = parse("A*29:02:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_18():
    result = parse("A*29:02:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_19():
    result = parse("A*29:02:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_01_20():
    result = parse("A*29:02:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_02():
    result = parse("A*29:02:02")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_03():
    result = parse("A*29:02:03")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_04():
    result = parse("A*29:02:04")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_05():
    result = parse("A*29:02:05")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_06():
    result = parse("A*29:02:06")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_07():
    result = parse("A*29:02:07")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_08():
    result = parse("A*29:02:08")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_09():
    result = parse("A*29:02:09")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_10():
    result = parse("A*29:02:10")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_11():
    result = parse("A*29:02:11")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_12():
    result = parse("A*29:02:12")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_13():
    result = parse("A*29:02:13")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_14():
    result = parse("A*29:02:14")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_15():
    result = parse("A*29:02:15")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_16():
    result = parse("A*29:02:16")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_17_01():
    result = parse("A*29:02:17:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:17:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:17:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_17_02():
    result = parse("A*29:02:17:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:02:17:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:02:17:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_18():
    result = parse("A*29:02:18")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_19():
    result = parse("A*29:02:19")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_20():
    result = parse("A*29:02:20")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_21():
    result = parse("A*29:02:21")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_22():
    result = parse("A*29:02:22")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_23():
    result = parse("A*29:02:23")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_24():
    result = parse("A*29:02:24")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_25():
    result = parse("A*29:02:25")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_26():
    result = parse("A*29:02:26")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_27():
    result = parse("A*29:02:27")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_28():
    result = parse("A*29:02:28")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_29():
    result = parse("A*29:02:29")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_02_30():
    result = parse("A*29:02:30")
    assert result.__class__ is Allele, f'Expected parse("A*29:02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:02:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_03():
    result = parse("A*29:03")
    assert result.__class__ is Allele, f'Expected parse("A*29:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_04():
    result = parse("A*29:04")
    assert result.__class__ is Allele, f'Expected parse("A*29:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_05():
    result = parse("A*29:05")
    assert result.__class__ is Allele, f'Expected parse("A*29:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_06():
    result = parse("A*29:06")
    assert result.__class__ is Allele, f'Expected parse("A*29:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_07():
    result = parse("A*29:07")
    assert result.__class__ is Allele, f'Expected parse("A*29:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_08N():
    result = parse("A*29:08N")
    assert result.__class__ is Allele, f'Expected parse("A*29:08N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:08N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_09():
    result = parse("A*29:09")
    assert result.__class__ is Allele, f'Expected parse("A*29:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_100():
    result = parse("A*29:100")
    assert result.__class__ is Allele, f'Expected parse("A*29:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_101_01():
    result = parse("A*29:101:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:101:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:101:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_101_02():
    result = parse("A*29:101:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:101:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:101:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_102():
    result = parse("A*29:102")
    assert result.__class__ is Allele, f'Expected parse("A*29:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_103():
    result = parse("A*29:103")
    assert result.__class__ is Allele, f'Expected parse("A*29:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_104():
    result = parse("A*29:104")
    assert result.__class__ is Allele, f'Expected parse("A*29:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_105():
    result = parse("A*29:105")
    assert result.__class__ is Allele, f'Expected parse("A*29:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_106():
    result = parse("A*29:106")
    assert result.__class__ is Allele, f'Expected parse("A*29:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_107():
    result = parse("A*29:107")
    assert result.__class__ is Allele, f'Expected parse("A*29:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_108():
    result = parse("A*29:108")
    assert result.__class__ is Allele, f'Expected parse("A*29:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_109():
    result = parse("A*29:109")
    assert result.__class__ is Allele, f'Expected parse("A*29:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_10_01():
    result = parse("A*29:10:01")
    assert result.__class__ is Allele, f'Expected parse("A*29:10:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:10:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_10_02():
    result = parse("A*29:10:02")
    assert result.__class__ is Allele, f'Expected parse("A*29:10:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*29:10:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_11():
    result = parse("A*29:11")
    assert result.__class__ is Allele, f'Expected parse("A*29:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_110():
    result = parse("A*29:110")
    assert result.__class__ is Allele, f'Expected parse("A*29:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_111():
    result = parse("A*29:111")
    assert result.__class__ is Allele, f'Expected parse("A*29:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_112N():
    result = parse("A*29:112N")
    assert result.__class__ is Allele, f'Expected parse("A*29:112N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:112N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_113():
    result = parse("A*29:113")
    assert result.__class__ is Allele, f'Expected parse("A*29:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_114():
    result = parse("A*29:114")
    assert result.__class__ is Allele, f'Expected parse("A*29:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_115():
    result = parse("A*29:115")
    assert result.__class__ is Allele, f'Expected parse("A*29:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_116():
    result = parse("A*29:116")
    assert result.__class__ is Allele, f'Expected parse("A*29:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_117():
    result = parse("A*29:117")
    assert result.__class__ is Allele, f'Expected parse("A*29:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_118():
    result = parse("A*29:118")
    assert result.__class__ is Allele, f'Expected parse("A*29:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_119():
    result = parse("A*29:119")
    assert result.__class__ is Allele, f'Expected parse("A*29:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_12():
    result = parse("A*29:12")
    assert result.__class__ is Allele, f'Expected parse("A*29:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_120():
    result = parse("A*29:120")
    assert result.__class__ is Allele, f'Expected parse("A*29:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_121():
    result = parse("A*29:121")
    assert result.__class__ is Allele, f'Expected parse("A*29:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_122():
    result = parse("A*29:122")
    assert result.__class__ is Allele, f'Expected parse("A*29:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_123():
    result = parse("A*29:123")
    assert result.__class__ is Allele, f'Expected parse("A*29:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_124():
    result = parse("A*29:124")
    assert result.__class__ is Allele, f'Expected parse("A*29:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_125():
    result = parse("A*29:125")
    assert result.__class__ is Allele, f'Expected parse("A*29:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_126Q():
    result = parse("A*29:126Q")
    assert result.__class__ is Allele, f'Expected parse("A*29:126Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:126Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_127():
    result = parse("A*29:127")
    assert result.__class__ is Allele, f'Expected parse("A*29:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_128():
    result = parse("A*29:128")
    assert result.__class__ is Allele, f'Expected parse("A*29:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_129():
    result = parse("A*29:129")
    assert result.__class__ is Allele, f'Expected parse("A*29:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_13():
    result = parse("A*29:13")
    assert result.__class__ is Allele, f'Expected parse("A*29:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_130():
    result = parse("A*29:130")
    assert result.__class__ is Allele, f'Expected parse("A*29:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_131():
    result = parse("A*29:131")
    assert result.__class__ is Allele, f'Expected parse("A*29:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_132():
    result = parse("A*29:132")
    assert result.__class__ is Allele, f'Expected parse("A*29:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_133_01_01():
    result = parse("A*29:133:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:133:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:133:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_133_01_02():
    result = parse("A*29:133:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*29:133:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*29:133:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_134():
    result = parse("A*29:134")
    assert result.__class__ is Allele, f'Expected parse("A*29:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_135():
    result = parse("A*29:135")
    assert result.__class__ is Allele, f'Expected parse("A*29:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_136():
    result = parse("A*29:136")
    assert result.__class__ is Allele, f'Expected parse("A*29:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_137():
    result = parse("A*29:137")
    assert result.__class__ is Allele, f'Expected parse("A*29:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_138():
    result = parse("A*29:138")
    assert result.__class__ is Allele, f'Expected parse("A*29:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_139():
    result = parse("A*29:139")
    assert result.__class__ is Allele, f'Expected parse("A*29:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_14():
    result = parse("A*29:14")
    assert result.__class__ is Allele, f'Expected parse("A*29:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_140():
    result = parse("A*29:140")
    assert result.__class__ is Allele, f'Expected parse("A*29:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_141():
    result = parse("A*29:141")
    assert result.__class__ is Allele, f'Expected parse("A*29:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_142():
    result = parse("A*29:142")
    assert result.__class__ is Allele, f'Expected parse("A*29:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_143():
    result = parse("A*29:143")
    assert result.__class__ is Allele, f'Expected parse("A*29:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_144():
    result = parse("A*29:144")
    assert result.__class__ is Allele, f'Expected parse("A*29:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_145():
    result = parse("A*29:145")
    assert result.__class__ is Allele, f'Expected parse("A*29:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_15():
    result = parse("A*29:15")
    assert result.__class__ is Allele, f'Expected parse("A*29:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_16():
    result = parse("A*29:16")
    assert result.__class__ is Allele, f'Expected parse("A*29:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_17():
    result = parse("A*29:17")
    assert result.__class__ is Allele, f'Expected parse("A*29:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_18():
    result = parse("A*29:18")
    assert result.__class__ is Allele, f'Expected parse("A*29:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_19():
    result = parse("A*29:19")
    assert result.__class__ is Allele, f'Expected parse("A*29:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_20():
    result = parse("A*29:20")
    assert result.__class__ is Allele, f'Expected parse("A*29:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_21():
    result = parse("A*29:21")
    assert result.__class__ is Allele, f'Expected parse("A*29:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_22():
    result = parse("A*29:22")
    assert result.__class__ is Allele, f'Expected parse("A*29:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_23():
    result = parse("A*29:23")
    assert result.__class__ is Allele, f'Expected parse("A*29:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_24():
    result = parse("A*29:24")
    assert result.__class__ is Allele, f'Expected parse("A*29:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_25():
    result = parse("A*29:25")
    assert result.__class__ is Allele, f'Expected parse("A*29:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_26():
    result = parse("A*29:26")
    assert result.__class__ is Allele, f'Expected parse("A*29:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_27():
    result = parse("A*29:27")
    assert result.__class__ is Allele, f'Expected parse("A*29:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_28():
    result = parse("A*29:28")
    assert result.__class__ is Allele, f'Expected parse("A*29:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_29():
    result = parse("A*29:29")
    assert result.__class__ is Allele, f'Expected parse("A*29:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_30():
    result = parse("A*29:30")
    assert result.__class__ is Allele, f'Expected parse("A*29:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_31():
    result = parse("A*29:31")
    assert result.__class__ is Allele, f'Expected parse("A*29:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_32():
    result = parse("A*29:32")
    assert result.__class__ is Allele, f'Expected parse("A*29:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_33():
    result = parse("A*29:33")
    assert result.__class__ is Allele, f'Expected parse("A*29:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_34():
    result = parse("A*29:34")
    assert result.__class__ is Allele, f'Expected parse("A*29:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_35():
    result = parse("A*29:35")
    assert result.__class__ is Allele, f'Expected parse("A*29:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_36():
    result = parse("A*29:36")
    assert result.__class__ is Allele, f'Expected parse("A*29:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_37():
    result = parse("A*29:37")
    assert result.__class__ is Allele, f'Expected parse("A*29:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_38():
    result = parse("A*29:38")
    assert result.__class__ is Allele, f'Expected parse("A*29:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_39():
    result = parse("A*29:39")
    assert result.__class__ is Allele, f'Expected parse("A*29:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_40():
    result = parse("A*29:40")
    assert result.__class__ is Allele, f'Expected parse("A*29:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_41():
    result = parse("A*29:41")
    assert result.__class__ is Allele, f'Expected parse("A*29:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_42():
    result = parse("A*29:42")
    assert result.__class__ is Allele, f'Expected parse("A*29:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_43():
    result = parse("A*29:43")
    assert result.__class__ is Allele, f'Expected parse("A*29:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_44():
    result = parse("A*29:44")
    assert result.__class__ is Allele, f'Expected parse("A*29:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_45():
    result = parse("A*29:45")
    assert result.__class__ is Allele, f'Expected parse("A*29:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_46():
    result = parse("A*29:46")
    assert result.__class__ is Allele, f'Expected parse("A*29:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_47():
    result = parse("A*29:47")
    assert result.__class__ is Allele, f'Expected parse("A*29:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_48():
    result = parse("A*29:48")
    assert result.__class__ is Allele, f'Expected parse("A*29:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_49():
    result = parse("A*29:49")
    assert result.__class__ is Allele, f'Expected parse("A*29:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_50():
    result = parse("A*29:50")
    assert result.__class__ is Allele, f'Expected parse("A*29:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_51():
    result = parse("A*29:51")
    assert result.__class__ is Allele, f'Expected parse("A*29:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_52():
    result = parse("A*29:52")
    assert result.__class__ is Allele, f'Expected parse("A*29:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_53():
    result = parse("A*29:53")
    assert result.__class__ is Allele, f'Expected parse("A*29:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_54():
    result = parse("A*29:54")
    assert result.__class__ is Allele, f'Expected parse("A*29:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_55():
    result = parse("A*29:55")
    assert result.__class__ is Allele, f'Expected parse("A*29:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_56():
    result = parse("A*29:56")
    assert result.__class__ is Allele, f'Expected parse("A*29:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_57():
    result = parse("A*29:57")
    assert result.__class__ is Allele, f'Expected parse("A*29:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_58():
    result = parse("A*29:58")
    assert result.__class__ is Allele, f'Expected parse("A*29:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_59():
    result = parse("A*29:59")
    assert result.__class__ is Allele, f'Expected parse("A*29:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_60():
    result = parse("A*29:60")
    assert result.__class__ is Allele, f'Expected parse("A*29:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_61():
    result = parse("A*29:61")
    assert result.__class__ is Allele, f'Expected parse("A*29:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_62():
    result = parse("A*29:62")
    assert result.__class__ is Allele, f'Expected parse("A*29:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_63():
    result = parse("A*29:63")
    assert result.__class__ is Allele, f'Expected parse("A*29:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_64():
    result = parse("A*29:64")
    assert result.__class__ is Allele, f'Expected parse("A*29:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_65():
    result = parse("A*29:65")
    assert result.__class__ is Allele, f'Expected parse("A*29:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_66():
    result = parse("A*29:66")
    assert result.__class__ is Allele, f'Expected parse("A*29:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_67():
    result = parse("A*29:67")
    assert result.__class__ is Allele, f'Expected parse("A*29:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_68():
    result = parse("A*29:68")
    assert result.__class__ is Allele, f'Expected parse("A*29:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_69():
    result = parse("A*29:69")
    assert result.__class__ is Allele, f'Expected parse("A*29:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_70():
    result = parse("A*29:70")
    assert result.__class__ is Allele, f'Expected parse("A*29:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_71():
    result = parse("A*29:71")
    assert result.__class__ is Allele, f'Expected parse("A*29:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_72():
    result = parse("A*29:72")
    assert result.__class__ is Allele, f'Expected parse("A*29:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_73():
    result = parse("A*29:73")
    assert result.__class__ is Allele, f'Expected parse("A*29:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_74():
    result = parse("A*29:74")
    assert result.__class__ is Allele, f'Expected parse("A*29:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_75():
    result = parse("A*29:75")
    assert result.__class__ is Allele, f'Expected parse("A*29:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_76():
    result = parse("A*29:76")
    assert result.__class__ is Allele, f'Expected parse("A*29:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_77():
    result = parse("A*29:77")
    assert result.__class__ is Allele, f'Expected parse("A*29:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_78N():
    result = parse("A*29:78N")
    assert result.__class__ is Allele, f'Expected parse("A*29:78N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:78N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_79():
    result = parse("A*29:79")
    assert result.__class__ is Allele, f'Expected parse("A*29:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_80():
    result = parse("A*29:80")
    assert result.__class__ is Allele, f'Expected parse("A*29:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_81():
    result = parse("A*29:81")
    assert result.__class__ is Allele, f'Expected parse("A*29:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_82():
    result = parse("A*29:82")
    assert result.__class__ is Allele, f'Expected parse("A*29:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_83():
    result = parse("A*29:83")
    assert result.__class__ is Allele, f'Expected parse("A*29:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_84():
    result = parse("A*29:84")
    assert result.__class__ is Allele, f'Expected parse("A*29:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_85():
    result = parse("A*29:85")
    assert result.__class__ is Allele, f'Expected parse("A*29:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_86():
    result = parse("A*29:86")
    assert result.__class__ is Allele, f'Expected parse("A*29:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_87():
    result = parse("A*29:87")
    assert result.__class__ is Allele, f'Expected parse("A*29:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_88():
    result = parse("A*29:88")
    assert result.__class__ is Allele, f'Expected parse("A*29:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_89():
    result = parse("A*29:89")
    assert result.__class__ is Allele, f'Expected parse("A*29:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_90():
    result = parse("A*29:90")
    assert result.__class__ is Allele, f'Expected parse("A*29:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_91():
    result = parse("A*29:91")
    assert result.__class__ is Allele, f'Expected parse("A*29:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_92():
    result = parse("A*29:92")
    assert result.__class__ is Allele, f'Expected parse("A*29:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_93():
    result = parse("A*29:93")
    assert result.__class__ is Allele, f'Expected parse("A*29:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_94():
    result = parse("A*29:94")
    assert result.__class__ is Allele, f'Expected parse("A*29:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_95():
    result = parse("A*29:95")
    assert result.__class__ is Allele, f'Expected parse("A*29:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_96():
    result = parse("A*29:96")
    assert result.__class__ is Allele, f'Expected parse("A*29:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_97():
    result = parse("A*29:97")
    assert result.__class__ is Allele, f'Expected parse("A*29:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_98():
    result = parse("A*29:98")
    assert result.__class__ is Allele, f'Expected parse("A*29:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_29_99():
    result = parse("A*29:99")
    assert result.__class__ is Allele, f'Expected parse("A*29:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*29:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_01_01():
    result = parse("A*30:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_01_02():
    result = parse("A*30:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_01_03():
    result = parse("A*30:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_01_04():
    result = parse("A*30:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_01_05():
    result = parse("A*30:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_01_06():
    result = parse("A*30:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_01_07():
    result = parse("A*30:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_01_08():
    result = parse("A*30:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_01_09():
    result = parse("A*30:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_01_10():
    result = parse("A*30:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_02():
    result = parse("A*30:01:02")
    assert result.__class__ is Allele, f'Expected parse("A*30:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_03():
    result = parse("A*30:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*30:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_04():
    result = parse("A*30:01:04")
    assert result.__class__ is Allele, f'Expected parse("A*30:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_05():
    result = parse("A*30:01:05")
    assert result.__class__ is Allele, f'Expected parse("A*30:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_06():
    result = parse("A*30:01:06")
    assert result.__class__ is Allele, f'Expected parse("A*30:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_07():
    result = parse("A*30:01:07")
    assert result.__class__ is Allele, f'Expected parse("A*30:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_08():
    result = parse("A*30:01:08")
    assert result.__class__ is Allele, f'Expected parse("A*30:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_09():
    result = parse("A*30:01:09")
    assert result.__class__ is Allele, f'Expected parse("A*30:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_10():
    result = parse("A*30:01:10")
    assert result.__class__ is Allele, f'Expected parse("A*30:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_11():
    result = parse("A*30:01:11")
    assert result.__class__ is Allele, f'Expected parse("A*30:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_12():
    result = parse("A*30:01:12")
    assert result.__class__ is Allele, f'Expected parse("A*30:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_13():
    result = parse("A*30:01:13")
    assert result.__class__ is Allele, f'Expected parse("A*30:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_14():
    result = parse("A*30:01:14")
    assert result.__class__ is Allele, f'Expected parse("A*30:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_15():
    result = parse("A*30:01:15")
    assert result.__class__ is Allele, f'Expected parse("A*30:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_16():
    result = parse("A*30:01:16")
    assert result.__class__ is Allele, f'Expected parse("A*30:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_01_17():
    result = parse("A*30:01:17")
    assert result.__class__ is Allele, f'Expected parse("A*30:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_01_01():
    result = parse("A*30:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_01_02():
    result = parse("A*30:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_01_03():
    result = parse("A*30:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_01_04():
    result = parse("A*30:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_01_05():
    result = parse("A*30:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_01_06():
    result = parse("A*30:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_01_07():
    result = parse("A*30:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_01_08():
    result = parse("A*30:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_01_09():
    result = parse("A*30:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_01_10():
    result = parse("A*30:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_01_11():
    result = parse("A*30:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_01_12():
    result = parse("A*30:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_01_13():
    result = parse("A*30:02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:02:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_01_14():
    result = parse("A*30:02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:02:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_02():
    result = parse("A*30:02:02")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_03():
    result = parse("A*30:02:03")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_04():
    result = parse("A*30:02:04")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_05():
    result = parse("A*30:02:05")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_06():
    result = parse("A*30:02:06")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_07():
    result = parse("A*30:02:07")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_08():
    result = parse("A*30:02:08")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_09():
    result = parse("A*30:02:09")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_10():
    result = parse("A*30:02:10")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_11():
    result = parse("A*30:02:11")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_12():
    result = parse("A*30:02:12")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_13():
    result = parse("A*30:02:13")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_14():
    result = parse("A*30:02:14")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_15():
    result = parse("A*30:02:15")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_16():
    result = parse("A*30:02:16")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_17():
    result = parse("A*30:02:17")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_18():
    result = parse("A*30:02:18")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_19():
    result = parse("A*30:02:19")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_20():
    result = parse("A*30:02:20")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_21():
    result = parse("A*30:02:21")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_22():
    result = parse("A*30:02:22")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_23():
    result = parse("A*30:02:23")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_24():
    result = parse("A*30:02:24")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_02_25():
    result = parse("A*30:02:25")
    assert result.__class__ is Allele, f'Expected parse("A*30:02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_03():
    result = parse("A*30:03")
    assert result.__class__ is Allele, f'Expected parse("A*30:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_04_01_01():
    result = parse("A*30:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_04_01_02():
    result = parse("A*30:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_04_02():
    result = parse("A*30:04:02")
    assert result.__class__ is Allele, f'Expected parse("A*30:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_04_03():
    result = parse("A*30:04:03")
    assert result.__class__ is Allele, f'Expected parse("A*30:04:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_06():
    result = parse("A*30:06")
    assert result.__class__ is Allele, f'Expected parse("A*30:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_07():
    result = parse("A*30:07")
    assert result.__class__ is Allele, f'Expected parse("A*30:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_08_01():
    result = parse("A*30:08:01")
    assert result.__class__ is Allele, f'Expected parse("A*30:08:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:08:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_08_02():
    result = parse("A*30:08:02")
    assert result.__class__ is Allele, f'Expected parse("A*30:08:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:08:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_09_01_01():
    result = parse("A*30:09:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:09:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:09:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_09_01_02():
    result = parse("A*30:09:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*30:09:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*30:09:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_10():
    result = parse("A*30:10")
    assert result.__class__ is Allele, f'Expected parse("A*30:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_100():
    result = parse("A*30:100")
    assert result.__class__ is Allele, f'Expected parse("A*30:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_101Q():
    result = parse("A*30:101Q")
    assert result.__class__ is Allele, f'Expected parse("A*30:101Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:101Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_102():
    result = parse("A*30:102")
    assert result.__class__ is Allele, f'Expected parse("A*30:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_103():
    result = parse("A*30:103")
    assert result.__class__ is Allele, f'Expected parse("A*30:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_104():
    result = parse("A*30:104")
    assert result.__class__ is Allele, f'Expected parse("A*30:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_105():
    result = parse("A*30:105")
    assert result.__class__ is Allele, f'Expected parse("A*30:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_106():
    result = parse("A*30:106")
    assert result.__class__ is Allele, f'Expected parse("A*30:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_107():
    result = parse("A*30:107")
    assert result.__class__ is Allele, f'Expected parse("A*30:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_108():
    result = parse("A*30:108")
    assert result.__class__ is Allele, f'Expected parse("A*30:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_109():
    result = parse("A*30:109")
    assert result.__class__ is Allele, f'Expected parse("A*30:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_110():
    result = parse("A*30:110")
    assert result.__class__ is Allele, f'Expected parse("A*30:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_111():
    result = parse("A*30:111")
    assert result.__class__ is Allele, f'Expected parse("A*30:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_112():
    result = parse("A*30:112")
    assert result.__class__ is Allele, f'Expected parse("A*30:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_113():
    result = parse("A*30:113")
    assert result.__class__ is Allele, f'Expected parse("A*30:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_114():
    result = parse("A*30:114")
    assert result.__class__ is Allele, f'Expected parse("A*30:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_115():
    result = parse("A*30:115")
    assert result.__class__ is Allele, f'Expected parse("A*30:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_116():
    result = parse("A*30:116")
    assert result.__class__ is Allele, f'Expected parse("A*30:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_117():
    result = parse("A*30:117")
    assert result.__class__ is Allele, f'Expected parse("A*30:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_118():
    result = parse("A*30:118")
    assert result.__class__ is Allele, f'Expected parse("A*30:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_119():
    result = parse("A*30:119")
    assert result.__class__ is Allele, f'Expected parse("A*30:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_11_01():
    result = parse("A*30:11:01")
    assert result.__class__ is Allele, f'Expected parse("A*30:11:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:11:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_11_02():
    result = parse("A*30:11:02")
    assert result.__class__ is Allele, f'Expected parse("A*30:11:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:11:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_120():
    result = parse("A*30:120")
    assert result.__class__ is Allele, f'Expected parse("A*30:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_121N():
    result = parse("A*30:121N")
    assert result.__class__ is Allele, f'Expected parse("A*30:121N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:121N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_122():
    result = parse("A*30:122")
    assert result.__class__ is Allele, f'Expected parse("A*30:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_123N():
    result = parse("A*30:123N")
    assert result.__class__ is Allele, f'Expected parse("A*30:123N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:123N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_124():
    result = parse("A*30:124")
    assert result.__class__ is Allele, f'Expected parse("A*30:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_125():
    result = parse("A*30:125")
    assert result.__class__ is Allele, f'Expected parse("A*30:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_126():
    result = parse("A*30:126")
    assert result.__class__ is Allele, f'Expected parse("A*30:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_127():
    result = parse("A*30:127")
    assert result.__class__ is Allele, f'Expected parse("A*30:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_128():
    result = parse("A*30:128")
    assert result.__class__ is Allele, f'Expected parse("A*30:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_129():
    result = parse("A*30:129")
    assert result.__class__ is Allele, f'Expected parse("A*30:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_12_01():
    result = parse("A*30:12:01")
    assert result.__class__ is Allele, f'Expected parse("A*30:12:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:12:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_12_02():
    result = parse("A*30:12:02")
    assert result.__class__ is Allele, f'Expected parse("A*30:12:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:12:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_13():
    result = parse("A*30:13")
    assert result.__class__ is Allele, f'Expected parse("A*30:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_130N():
    result = parse("A*30:130N")
    assert result.__class__ is Allele, f'Expected parse("A*30:130N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:130N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_131():
    result = parse("A*30:131")
    assert result.__class__ is Allele, f'Expected parse("A*30:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_132N():
    result = parse("A*30:132N")
    assert result.__class__ is Allele, f'Expected parse("A*30:132N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:132N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_133():
    result = parse("A*30:133")
    assert result.__class__ is Allele, f'Expected parse("A*30:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_134():
    result = parse("A*30:134")
    assert result.__class__ is Allele, f'Expected parse("A*30:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_135():
    result = parse("A*30:135")
    assert result.__class__ is Allele, f'Expected parse("A*30:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_136():
    result = parse("A*30:136")
    assert result.__class__ is Allele, f'Expected parse("A*30:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_137():
    result = parse("A*30:137")
    assert result.__class__ is Allele, f'Expected parse("A*30:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_138():
    result = parse("A*30:138")
    assert result.__class__ is Allele, f'Expected parse("A*30:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_139():
    result = parse("A*30:139")
    assert result.__class__ is Allele, f'Expected parse("A*30:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_140():
    result = parse("A*30:140")
    assert result.__class__ is Allele, f'Expected parse("A*30:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_141():
    result = parse("A*30:141")
    assert result.__class__ is Allele, f'Expected parse("A*30:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_142():
    result = parse("A*30:142")
    assert result.__class__ is Allele, f'Expected parse("A*30:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_143():
    result = parse("A*30:143")
    assert result.__class__ is Allele, f'Expected parse("A*30:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_144():
    result = parse("A*30:144")
    assert result.__class__ is Allele, f'Expected parse("A*30:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_145N():
    result = parse("A*30:145N")
    assert result.__class__ is Allele, f'Expected parse("A*30:145N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:145N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_146():
    result = parse("A*30:146")
    assert result.__class__ is Allele, f'Expected parse("A*30:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_147():
    result = parse("A*30:147")
    assert result.__class__ is Allele, f'Expected parse("A*30:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_148():
    result = parse("A*30:148")
    assert result.__class__ is Allele, f'Expected parse("A*30:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_149():
    result = parse("A*30:149")
    assert result.__class__ is Allele, f'Expected parse("A*30:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_14L():
    result = parse("A*30:14L")
    assert result.__class__ is Allele, f'Expected parse("A*30:14L") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:14L") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_15():
    result = parse("A*30:15")
    assert result.__class__ is Allele, f'Expected parse("A*30:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_150():
    result = parse("A*30:150")
    assert result.__class__ is Allele, f'Expected parse("A*30:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_151():
    result = parse("A*30:151")
    assert result.__class__ is Allele, f'Expected parse("A*30:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_152():
    result = parse("A*30:152")
    assert result.__class__ is Allele, f'Expected parse("A*30:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_153():
    result = parse("A*30:153")
    assert result.__class__ is Allele, f'Expected parse("A*30:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_154():
    result = parse("A*30:154")
    assert result.__class__ is Allele, f'Expected parse("A*30:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_155():
    result = parse("A*30:155")
    assert result.__class__ is Allele, f'Expected parse("A*30:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_156():
    result = parse("A*30:156")
    assert result.__class__ is Allele, f'Expected parse("A*30:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_157():
    result = parse("A*30:157")
    assert result.__class__ is Allele, f'Expected parse("A*30:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_158N():
    result = parse("A*30:158N")
    assert result.__class__ is Allele, f'Expected parse("A*30:158N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:158N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_159():
    result = parse("A*30:159")
    assert result.__class__ is Allele, f'Expected parse("A*30:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_16():
    result = parse("A*30:16")
    assert result.__class__ is Allele, f'Expected parse("A*30:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_160():
    result = parse("A*30:160")
    assert result.__class__ is Allele, f'Expected parse("A*30:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_161():
    result = parse("A*30:161")
    assert result.__class__ is Allele, f'Expected parse("A*30:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_162():
    result = parse("A*30:162")
    assert result.__class__ is Allele, f'Expected parse("A*30:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_163():
    result = parse("A*30:163")
    assert result.__class__ is Allele, f'Expected parse("A*30:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_164():
    result = parse("A*30:164")
    assert result.__class__ is Allele, f'Expected parse("A*30:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_165():
    result = parse("A*30:165")
    assert result.__class__ is Allele, f'Expected parse("A*30:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_166():
    result = parse("A*30:166")
    assert result.__class__ is Allele, f'Expected parse("A*30:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_167():
    result = parse("A*30:167")
    assert result.__class__ is Allele, f'Expected parse("A*30:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_168():
    result = parse("A*30:168")
    assert result.__class__ is Allele, f'Expected parse("A*30:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_169():
    result = parse("A*30:169")
    assert result.__class__ is Allele, f'Expected parse("A*30:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_17():
    result = parse("A*30:17")
    assert result.__class__ is Allele, f'Expected parse("A*30:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_170():
    result = parse("A*30:170")
    assert result.__class__ is Allele, f'Expected parse("A*30:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_171():
    result = parse("A*30:171")
    assert result.__class__ is Allele, f'Expected parse("A*30:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_172():
    result = parse("A*30:172")
    assert result.__class__ is Allele, f'Expected parse("A*30:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_173():
    result = parse("A*30:173")
    assert result.__class__ is Allele, f'Expected parse("A*30:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_174():
    result = parse("A*30:174")
    assert result.__class__ is Allele, f'Expected parse("A*30:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_175():
    result = parse("A*30:175")
    assert result.__class__ is Allele, f'Expected parse("A*30:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_18():
    result = parse("A*30:18")
    assert result.__class__ is Allele, f'Expected parse("A*30:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_19():
    result = parse("A*30:19")
    assert result.__class__ is Allele, f'Expected parse("A*30:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_20():
    result = parse("A*30:20")
    assert result.__class__ is Allele, f'Expected parse("A*30:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_22():
    result = parse("A*30:22")
    assert result.__class__ is Allele, f'Expected parse("A*30:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_23():
    result = parse("A*30:23")
    assert result.__class__ is Allele, f'Expected parse("A*30:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_24():
    result = parse("A*30:24")
    assert result.__class__ is Allele, f'Expected parse("A*30:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_25():
    result = parse("A*30:25")
    assert result.__class__ is Allele, f'Expected parse("A*30:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_26():
    result = parse("A*30:26")
    assert result.__class__ is Allele, f'Expected parse("A*30:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_27N():
    result = parse("A*30:27N")
    assert result.__class__ is Allele, f'Expected parse("A*30:27N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:27N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_28():
    result = parse("A*30:28")
    assert result.__class__ is Allele, f'Expected parse("A*30:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_29():
    result = parse("A*30:29")
    assert result.__class__ is Allele, f'Expected parse("A*30:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_30():
    result = parse("A*30:30")
    assert result.__class__ is Allele, f'Expected parse("A*30:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_31():
    result = parse("A*30:31")
    assert result.__class__ is Allele, f'Expected parse("A*30:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_32():
    result = parse("A*30:32")
    assert result.__class__ is Allele, f'Expected parse("A*30:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_33():
    result = parse("A*30:33")
    assert result.__class__ is Allele, f'Expected parse("A*30:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_34():
    result = parse("A*30:34")
    assert result.__class__ is Allele, f'Expected parse("A*30:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_35():
    result = parse("A*30:35")
    assert result.__class__ is Allele, f'Expected parse("A*30:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_36():
    result = parse("A*30:36")
    assert result.__class__ is Allele, f'Expected parse("A*30:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_37():
    result = parse("A*30:37")
    assert result.__class__ is Allele, f'Expected parse("A*30:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_38():
    result = parse("A*30:38")
    assert result.__class__ is Allele, f'Expected parse("A*30:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_39_01():
    result = parse("A*30:39:01")
    assert result.__class__ is Allele, f'Expected parse("A*30:39:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:39:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_39_02():
    result = parse("A*30:39:02")
    assert result.__class__ is Allele, f'Expected parse("A*30:39:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*30:39:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_40():
    result = parse("A*30:40")
    assert result.__class__ is Allele, f'Expected parse("A*30:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_41():
    result = parse("A*30:41")
    assert result.__class__ is Allele, f'Expected parse("A*30:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_42():
    result = parse("A*30:42")
    assert result.__class__ is Allele, f'Expected parse("A*30:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_43():
    result = parse("A*30:43")
    assert result.__class__ is Allele, f'Expected parse("A*30:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_44():
    result = parse("A*30:44")
    assert result.__class__ is Allele, f'Expected parse("A*30:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_45():
    result = parse("A*30:45")
    assert result.__class__ is Allele, f'Expected parse("A*30:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_46():
    result = parse("A*30:46")
    assert result.__class__ is Allele, f'Expected parse("A*30:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_47():
    result = parse("A*30:47")
    assert result.__class__ is Allele, f'Expected parse("A*30:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_48():
    result = parse("A*30:48")
    assert result.__class__ is Allele, f'Expected parse("A*30:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_49():
    result = parse("A*30:49")
    assert result.__class__ is Allele, f'Expected parse("A*30:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_50():
    result = parse("A*30:50")
    assert result.__class__ is Allele, f'Expected parse("A*30:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_51():
    result = parse("A*30:51")
    assert result.__class__ is Allele, f'Expected parse("A*30:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_52():
    result = parse("A*30:52")
    assert result.__class__ is Allele, f'Expected parse("A*30:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_53():
    result = parse("A*30:53")
    assert result.__class__ is Allele, f'Expected parse("A*30:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_54():
    result = parse("A*30:54")
    assert result.__class__ is Allele, f'Expected parse("A*30:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_55():
    result = parse("A*30:55")
    assert result.__class__ is Allele, f'Expected parse("A*30:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_56():
    result = parse("A*30:56")
    assert result.__class__ is Allele, f'Expected parse("A*30:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_57():
    result = parse("A*30:57")
    assert result.__class__ is Allele, f'Expected parse("A*30:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_58():
    result = parse("A*30:58")
    assert result.__class__ is Allele, f'Expected parse("A*30:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_59N():
    result = parse("A*30:59N")
    assert result.__class__ is Allele, f'Expected parse("A*30:59N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:59N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_60():
    result = parse("A*30:60")
    assert result.__class__ is Allele, f'Expected parse("A*30:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_61():
    result = parse("A*30:61")
    assert result.__class__ is Allele, f'Expected parse("A*30:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_62():
    result = parse("A*30:62")
    assert result.__class__ is Allele, f'Expected parse("A*30:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_63():
    result = parse("A*30:63")
    assert result.__class__ is Allele, f'Expected parse("A*30:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_64():
    result = parse("A*30:64")
    assert result.__class__ is Allele, f'Expected parse("A*30:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_65():
    result = parse("A*30:65")
    assert result.__class__ is Allele, f'Expected parse("A*30:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_66():
    result = parse("A*30:66")
    assert result.__class__ is Allele, f'Expected parse("A*30:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_67():
    result = parse("A*30:67")
    assert result.__class__ is Allele, f'Expected parse("A*30:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_68():
    result = parse("A*30:68")
    assert result.__class__ is Allele, f'Expected parse("A*30:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_69():
    result = parse("A*30:69")
    assert result.__class__ is Allele, f'Expected parse("A*30:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_70N():
    result = parse("A*30:70N")
    assert result.__class__ is Allele, f'Expected parse("A*30:70N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:70N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_71():
    result = parse("A*30:71")
    assert result.__class__ is Allele, f'Expected parse("A*30:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_72():
    result = parse("A*30:72")
    assert result.__class__ is Allele, f'Expected parse("A*30:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_73N():
    result = parse("A*30:73N")
    assert result.__class__ is Allele, f'Expected parse("A*30:73N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:73N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_74():
    result = parse("A*30:74")
    assert result.__class__ is Allele, f'Expected parse("A*30:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_75():
    result = parse("A*30:75")
    assert result.__class__ is Allele, f'Expected parse("A*30:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_76N():
    result = parse("A*30:76N")
    assert result.__class__ is Allele, f'Expected parse("A*30:76N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:76N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_77():
    result = parse("A*30:77")
    assert result.__class__ is Allele, f'Expected parse("A*30:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_78N():
    result = parse("A*30:78N")
    assert result.__class__ is Allele, f'Expected parse("A*30:78N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:78N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_79():
    result = parse("A*30:79")
    assert result.__class__ is Allele, f'Expected parse("A*30:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_80():
    result = parse("A*30:80")
    assert result.__class__ is Allele, f'Expected parse("A*30:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_81():
    result = parse("A*30:81")
    assert result.__class__ is Allele, f'Expected parse("A*30:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_82():
    result = parse("A*30:82")
    assert result.__class__ is Allele, f'Expected parse("A*30:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_83():
    result = parse("A*30:83")
    assert result.__class__ is Allele, f'Expected parse("A*30:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_84():
    result = parse("A*30:84")
    assert result.__class__ is Allele, f'Expected parse("A*30:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_85():
    result = parse("A*30:85")
    assert result.__class__ is Allele, f'Expected parse("A*30:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_86():
    result = parse("A*30:86")
    assert result.__class__ is Allele, f'Expected parse("A*30:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_87():
    result = parse("A*30:87")
    assert result.__class__ is Allele, f'Expected parse("A*30:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_88():
    result = parse("A*30:88")
    assert result.__class__ is Allele, f'Expected parse("A*30:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_89():
    result = parse("A*30:89")
    assert result.__class__ is Allele, f'Expected parse("A*30:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_90():
    result = parse("A*30:90")
    assert result.__class__ is Allele, f'Expected parse("A*30:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_91():
    result = parse("A*30:91")
    assert result.__class__ is Allele, f'Expected parse("A*30:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_92():
    result = parse("A*30:92")
    assert result.__class__ is Allele, f'Expected parse("A*30:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_93():
    result = parse("A*30:93")
    assert result.__class__ is Allele, f'Expected parse("A*30:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_94():
    result = parse("A*30:94")
    assert result.__class__ is Allele, f'Expected parse("A*30:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_95():
    result = parse("A*30:95")
    assert result.__class__ is Allele, f'Expected parse("A*30:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_96():
    result = parse("A*30:96")
    assert result.__class__ is Allele, f'Expected parse("A*30:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_97():
    result = parse("A*30:97")
    assert result.__class__ is Allele, f'Expected parse("A*30:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_98():
    result = parse("A*30:98")
    assert result.__class__ is Allele, f'Expected parse("A*30:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_30_99():
    result = parse("A*30:99")
    assert result.__class__ is Allele, f'Expected parse("A*30:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*30:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_01():
    result = parse("A*31:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_02():
    result = parse("A*31:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_03N():
    result = parse("A*31:01:02:03N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:03N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:03N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_04():
    result = parse("A*31:01:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_05():
    result = parse("A*31:01:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_06():
    result = parse("A*31:01:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_07():
    result = parse("A*31:01:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_08():
    result = parse("A*31:01:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_09():
    result = parse("A*31:01:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_10():
    result = parse("A*31:01:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_11():
    result = parse("A*31:01:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_12():
    result = parse("A*31:01:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_13():
    result = parse("A*31:01:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_14():
    result = parse("A*31:01:02:14")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_15():
    result = parse("A*31:01:02:15")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_16():
    result = parse("A*31:01:02:16")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_17():
    result = parse("A*31:01:02:17")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_18():
    result = parse("A*31:01:02:18")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_19():
    result = parse("A*31:01:02:19")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_20():
    result = parse("A*31:01:02:20")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_21():
    result = parse("A*31:01:02:21")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_22():
    result = parse("A*31:01:02:22")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_23():
    result = parse("A*31:01:02:23")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_24():
    result = parse("A*31:01:02:24")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_25():
    result = parse("A*31:01:02:25")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_26():
    result = parse("A*31:01:02:26")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_27():
    result = parse("A*31:01:02:27")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_28():
    result = parse("A*31:01:02:28")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_29():
    result = parse("A*31:01:02:29")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_02_30Q():
    result = parse("A*31:01:02:30Q")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:01:02:30Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:01:02:30Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_03():
    result = parse("A*31:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_04():
    result = parse("A*31:01:04")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_05():
    result = parse("A*31:01:05")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_06():
    result = parse("A*31:01:06")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_07():
    result = parse("A*31:01:07")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_08():
    result = parse("A*31:01:08")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_09():
    result = parse("A*31:01:09")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_10():
    result = parse("A*31:01:10")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_11():
    result = parse("A*31:01:11")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_12():
    result = parse("A*31:01:12")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_13():
    result = parse("A*31:01:13")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_14():
    result = parse("A*31:01:14")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_15():
    result = parse("A*31:01:15")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_16():
    result = parse("A*31:01:16")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_17():
    result = parse("A*31:01:17")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_18():
    result = parse("A*31:01:18")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_19():
    result = parse("A*31:01:19")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_20():
    result = parse("A*31:01:20")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_21():
    result = parse("A*31:01:21")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_22():
    result = parse("A*31:01:22")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_23():
    result = parse("A*31:01:23")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_24():
    result = parse("A*31:01:24")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_25():
    result = parse("A*31:01:25")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_26():
    result = parse("A*31:01:26")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_27():
    result = parse("A*31:01:27")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_28():
    result = parse("A*31:01:28")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_29():
    result = parse("A*31:01:29")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_30():
    result = parse("A*31:01:30")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_31():
    result = parse("A*31:01:31")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_32():
    result = parse("A*31:01:32")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_33():
    result = parse("A*31:01:33")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_34():
    result = parse("A*31:01:34")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_35():
    result = parse("A*31:01:35")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_36():
    result = parse("A*31:01:36")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_37():
    result = parse("A*31:01:37")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_38():
    result = parse("A*31:01:38")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_39():
    result = parse("A*31:01:39")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_40():
    result = parse("A*31:01:40")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_41():
    result = parse("A*31:01:41")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_42():
    result = parse("A*31:01:42")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_43():
    result = parse("A*31:01:43")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_44():
    result = parse("A*31:01:44")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_01_45():
    result = parse("A*31:01:45")
    assert result.__class__ is Allele, f'Expected parse("A*31:01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_02_01():
    result = parse("A*31:02:01")
    assert result.__class__ is Allele, f'Expected parse("A*31:02:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_02_02():
    result = parse("A*31:02:02")
    assert result.__class__ is Allele, f'Expected parse("A*31:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_03():
    result = parse("A*31:03")
    assert result.__class__ is Allele, f'Expected parse("A*31:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_04_01_01():
    result = parse("A*31:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_04_01_02():
    result = parse("A*31:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*31:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*31:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_04_02():
    result = parse("A*31:04:02")
    assert result.__class__ is Allele, f'Expected parse("A*31:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*31:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_05():
    result = parse("A*31:05")
    assert result.__class__ is Allele, f'Expected parse("A*31:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_06():
    result = parse("A*31:06")
    assert result.__class__ is Allele, f'Expected parse("A*31:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_07():
    result = parse("A*31:07")
    assert result.__class__ is Allele, f'Expected parse("A*31:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_08():
    result = parse("A*31:08")
    assert result.__class__ is Allele, f'Expected parse("A*31:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_09():
    result = parse("A*31:09")
    assert result.__class__ is Allele, f'Expected parse("A*31:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_10():
    result = parse("A*31:10")
    assert result.__class__ is Allele, f'Expected parse("A*31:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_100():
    result = parse("A*31:100")
    assert result.__class__ is Allele, f'Expected parse("A*31:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_101():
    result = parse("A*31:101")
    assert result.__class__ is Allele, f'Expected parse("A*31:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_102():
    result = parse("A*31:102")
    assert result.__class__ is Allele, f'Expected parse("A*31:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_103():
    result = parse("A*31:103")
    assert result.__class__ is Allele, f'Expected parse("A*31:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_104():
    result = parse("A*31:104")
    assert result.__class__ is Allele, f'Expected parse("A*31:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_105():
    result = parse("A*31:105")
    assert result.__class__ is Allele, f'Expected parse("A*31:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_106():
    result = parse("A*31:106")
    assert result.__class__ is Allele, f'Expected parse("A*31:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_107():
    result = parse("A*31:107")
    assert result.__class__ is Allele, f'Expected parse("A*31:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_108():
    result = parse("A*31:108")
    assert result.__class__ is Allele, f'Expected parse("A*31:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_109():
    result = parse("A*31:109")
    assert result.__class__ is Allele, f'Expected parse("A*31:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_11():
    result = parse("A*31:11")
    assert result.__class__ is Allele, f'Expected parse("A*31:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_110():
    result = parse("A*31:110")
    assert result.__class__ is Allele, f'Expected parse("A*31:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_111():
    result = parse("A*31:111")
    assert result.__class__ is Allele, f'Expected parse("A*31:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_112():
    result = parse("A*31:112")
    assert result.__class__ is Allele, f'Expected parse("A*31:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_113():
    result = parse("A*31:113")
    assert result.__class__ is Allele, f'Expected parse("A*31:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_114():
    result = parse("A*31:114")
    assert result.__class__ is Allele, f'Expected parse("A*31:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_115():
    result = parse("A*31:115")
    assert result.__class__ is Allele, f'Expected parse("A*31:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_116():
    result = parse("A*31:116")
    assert result.__class__ is Allele, f'Expected parse("A*31:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_117():
    result = parse("A*31:117")
    assert result.__class__ is Allele, f'Expected parse("A*31:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_118():
    result = parse("A*31:118")
    assert result.__class__ is Allele, f'Expected parse("A*31:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_119():
    result = parse("A*31:119")
    assert result.__class__ is Allele, f'Expected parse("A*31:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_12():
    result = parse("A*31:12")
    assert result.__class__ is Allele, f'Expected parse("A*31:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_120():
    result = parse("A*31:120")
    assert result.__class__ is Allele, f'Expected parse("A*31:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_121():
    result = parse("A*31:121")
    assert result.__class__ is Allele, f'Expected parse("A*31:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_122():
    result = parse("A*31:122")
    assert result.__class__ is Allele, f'Expected parse("A*31:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_123():
    result = parse("A*31:123")
    assert result.__class__ is Allele, f'Expected parse("A*31:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_124():
    result = parse("A*31:124")
    assert result.__class__ is Allele, f'Expected parse("A*31:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_125():
    result = parse("A*31:125")
    assert result.__class__ is Allele, f'Expected parse("A*31:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_126N():
    result = parse("A*31:126N")
    assert result.__class__ is Allele, f'Expected parse("A*31:126N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:126N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_127():
    result = parse("A*31:127")
    assert result.__class__ is Allele, f'Expected parse("A*31:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_128():
    result = parse("A*31:128")
    assert result.__class__ is Allele, f'Expected parse("A*31:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_129():
    result = parse("A*31:129")
    assert result.__class__ is Allele, f'Expected parse("A*31:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_13():
    result = parse("A*31:13")
    assert result.__class__ is Allele, f'Expected parse("A*31:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_130():
    result = parse("A*31:130")
    assert result.__class__ is Allele, f'Expected parse("A*31:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_131N():
    result = parse("A*31:131N")
    assert result.__class__ is Allele, f'Expected parse("A*31:131N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:131N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_132():
    result = parse("A*31:132")
    assert result.__class__ is Allele, f'Expected parse("A*31:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_133():
    result = parse("A*31:133")
    assert result.__class__ is Allele, f'Expected parse("A*31:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_134():
    result = parse("A*31:134")
    assert result.__class__ is Allele, f'Expected parse("A*31:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_135():
    result = parse("A*31:135")
    assert result.__class__ is Allele, f'Expected parse("A*31:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_136():
    result = parse("A*31:136")
    assert result.__class__ is Allele, f'Expected parse("A*31:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_137():
    result = parse("A*31:137")
    assert result.__class__ is Allele, f'Expected parse("A*31:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_138():
    result = parse("A*31:138")
    assert result.__class__ is Allele, f'Expected parse("A*31:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_139():
    result = parse("A*31:139")
    assert result.__class__ is Allele, f'Expected parse("A*31:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_140():
    result = parse("A*31:140")
    assert result.__class__ is Allele, f'Expected parse("A*31:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_141N():
    result = parse("A*31:141N")
    assert result.__class__ is Allele, f'Expected parse("A*31:141N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:141N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_142():
    result = parse("A*31:142")
    assert result.__class__ is Allele, f'Expected parse("A*31:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_143():
    result = parse("A*31:143")
    assert result.__class__ is Allele, f'Expected parse("A*31:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_144():
    result = parse("A*31:144")
    assert result.__class__ is Allele, f'Expected parse("A*31:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_145():
    result = parse("A*31:145")
    assert result.__class__ is Allele, f'Expected parse("A*31:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_146():
    result = parse("A*31:146")
    assert result.__class__ is Allele, f'Expected parse("A*31:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_147():
    result = parse("A*31:147")
    assert result.__class__ is Allele, f'Expected parse("A*31:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_148():
    result = parse("A*31:148")
    assert result.__class__ is Allele, f'Expected parse("A*31:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_149N():
    result = parse("A*31:149N")
    assert result.__class__ is Allele, f'Expected parse("A*31:149N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:149N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_14N():
    result = parse("A*31:14N")
    assert result.__class__ is Allele, f'Expected parse("A*31:14N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:14N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_15():
    result = parse("A*31:15")
    assert result.__class__ is Allele, f'Expected parse("A*31:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_150():
    result = parse("A*31:150")
    assert result.__class__ is Allele, f'Expected parse("A*31:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_151Q():
    result = parse("A*31:151Q")
    assert result.__class__ is Allele, f'Expected parse("A*31:151Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:151Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_152():
    result = parse("A*31:152")
    assert result.__class__ is Allele, f'Expected parse("A*31:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_153():
    result = parse("A*31:153")
    assert result.__class__ is Allele, f'Expected parse("A*31:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_154():
    result = parse("A*31:154")
    assert result.__class__ is Allele, f'Expected parse("A*31:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_155():
    result = parse("A*31:155")
    assert result.__class__ is Allele, f'Expected parse("A*31:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_156():
    result = parse("A*31:156")
    assert result.__class__ is Allele, f'Expected parse("A*31:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_157():
    result = parse("A*31:157")
    assert result.__class__ is Allele, f'Expected parse("A*31:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_158N():
    result = parse("A*31:158N")
    assert result.__class__ is Allele, f'Expected parse("A*31:158N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:158N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_159():
    result = parse("A*31:159")
    assert result.__class__ is Allele, f'Expected parse("A*31:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_16():
    result = parse("A*31:16")
    assert result.__class__ is Allele, f'Expected parse("A*31:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_160():
    result = parse("A*31:160")
    assert result.__class__ is Allele, f'Expected parse("A*31:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_161():
    result = parse("A*31:161")
    assert result.__class__ is Allele, f'Expected parse("A*31:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_162():
    result = parse("A*31:162")
    assert result.__class__ is Allele, f'Expected parse("A*31:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_163():
    result = parse("A*31:163")
    assert result.__class__ is Allele, f'Expected parse("A*31:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_164():
    result = parse("A*31:164")
    assert result.__class__ is Allele, f'Expected parse("A*31:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_165():
    result = parse("A*31:165")
    assert result.__class__ is Allele, f'Expected parse("A*31:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_166():
    result = parse("A*31:166")
    assert result.__class__ is Allele, f'Expected parse("A*31:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_167():
    result = parse("A*31:167")
    assert result.__class__ is Allele, f'Expected parse("A*31:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_168():
    result = parse("A*31:168")
    assert result.__class__ is Allele, f'Expected parse("A*31:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_169():
    result = parse("A*31:169")
    assert result.__class__ is Allele, f'Expected parse("A*31:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_17():
    result = parse("A*31:17")
    assert result.__class__ is Allele, f'Expected parse("A*31:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_170():
    result = parse("A*31:170")
    assert result.__class__ is Allele, f'Expected parse("A*31:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_171():
    result = parse("A*31:171")
    assert result.__class__ is Allele, f'Expected parse("A*31:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_172():
    result = parse("A*31:172")
    assert result.__class__ is Allele, f'Expected parse("A*31:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_173():
    result = parse("A*31:173")
    assert result.__class__ is Allele, f'Expected parse("A*31:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_174():
    result = parse("A*31:174")
    assert result.__class__ is Allele, f'Expected parse("A*31:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_175():
    result = parse("A*31:175")
    assert result.__class__ is Allele, f'Expected parse("A*31:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_176():
    result = parse("A*31:176")
    assert result.__class__ is Allele, f'Expected parse("A*31:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_177():
    result = parse("A*31:177")
    assert result.__class__ is Allele, f'Expected parse("A*31:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_178():
    result = parse("A*31:178")
    assert result.__class__ is Allele, f'Expected parse("A*31:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_179():
    result = parse("A*31:179")
    assert result.__class__ is Allele, f'Expected parse("A*31:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_18():
    result = parse("A*31:18")
    assert result.__class__ is Allele, f'Expected parse("A*31:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_180():
    result = parse("A*31:180")
    assert result.__class__ is Allele, f'Expected parse("A*31:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_181():
    result = parse("A*31:181")
    assert result.__class__ is Allele, f'Expected parse("A*31:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_182():
    result = parse("A*31:182")
    assert result.__class__ is Allele, f'Expected parse("A*31:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_183():
    result = parse("A*31:183")
    assert result.__class__ is Allele, f'Expected parse("A*31:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_19():
    result = parse("A*31:19")
    assert result.__class__ is Allele, f'Expected parse("A*31:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_20():
    result = parse("A*31:20")
    assert result.__class__ is Allele, f'Expected parse("A*31:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_21():
    result = parse("A*31:21")
    assert result.__class__ is Allele, f'Expected parse("A*31:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_22():
    result = parse("A*31:22")
    assert result.__class__ is Allele, f'Expected parse("A*31:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_23():
    result = parse("A*31:23")
    assert result.__class__ is Allele, f'Expected parse("A*31:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_24():
    result = parse("A*31:24")
    assert result.__class__ is Allele, f'Expected parse("A*31:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_25():
    result = parse("A*31:25")
    assert result.__class__ is Allele, f'Expected parse("A*31:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_26():
    result = parse("A*31:26")
    assert result.__class__ is Allele, f'Expected parse("A*31:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_27():
    result = parse("A*31:27")
    assert result.__class__ is Allele, f'Expected parse("A*31:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_28():
    result = parse("A*31:28")
    assert result.__class__ is Allele, f'Expected parse("A*31:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_29():
    result = parse("A*31:29")
    assert result.__class__ is Allele, f'Expected parse("A*31:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_30():
    result = parse("A*31:30")
    assert result.__class__ is Allele, f'Expected parse("A*31:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_31():
    result = parse("A*31:31")
    assert result.__class__ is Allele, f'Expected parse("A*31:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_32():
    result = parse("A*31:32")
    assert result.__class__ is Allele, f'Expected parse("A*31:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_33():
    result = parse("A*31:33")
    assert result.__class__ is Allele, f'Expected parse("A*31:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_34():
    result = parse("A*31:34")
    assert result.__class__ is Allele, f'Expected parse("A*31:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_35():
    result = parse("A*31:35")
    assert result.__class__ is Allele, f'Expected parse("A*31:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_36():
    result = parse("A*31:36")
    assert result.__class__ is Allele, f'Expected parse("A*31:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_37():
    result = parse("A*31:37")
    assert result.__class__ is Allele, f'Expected parse("A*31:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_38():
    result = parse("A*31:38")
    assert result.__class__ is Allele, f'Expected parse("A*31:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_39():
    result = parse("A*31:39")
    assert result.__class__ is Allele, f'Expected parse("A*31:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_40():
    result = parse("A*31:40")
    assert result.__class__ is Allele, f'Expected parse("A*31:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_41():
    result = parse("A*31:41")
    assert result.__class__ is Allele, f'Expected parse("A*31:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_42():
    result = parse("A*31:42")
    assert result.__class__ is Allele, f'Expected parse("A*31:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_43():
    result = parse("A*31:43")
    assert result.__class__ is Allele, f'Expected parse("A*31:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_44():
    result = parse("A*31:44")
    assert result.__class__ is Allele, f'Expected parse("A*31:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_45():
    result = parse("A*31:45")
    assert result.__class__ is Allele, f'Expected parse("A*31:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_46():
    result = parse("A*31:46")
    assert result.__class__ is Allele, f'Expected parse("A*31:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_47():
    result = parse("A*31:47")
    assert result.__class__ is Allele, f'Expected parse("A*31:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_48():
    result = parse("A*31:48")
    assert result.__class__ is Allele, f'Expected parse("A*31:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_49():
    result = parse("A*31:49")
    assert result.__class__ is Allele, f'Expected parse("A*31:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_50():
    result = parse("A*31:50")
    assert result.__class__ is Allele, f'Expected parse("A*31:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_51():
    result = parse("A*31:51")
    assert result.__class__ is Allele, f'Expected parse("A*31:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_52():
    result = parse("A*31:52")
    assert result.__class__ is Allele, f'Expected parse("A*31:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_53():
    result = parse("A*31:53")
    assert result.__class__ is Allele, f'Expected parse("A*31:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_54():
    result = parse("A*31:54")
    assert result.__class__ is Allele, f'Expected parse("A*31:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_55():
    result = parse("A*31:55")
    assert result.__class__ is Allele, f'Expected parse("A*31:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_56():
    result = parse("A*31:56")
    assert result.__class__ is Allele, f'Expected parse("A*31:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_57():
    result = parse("A*31:57")
    assert result.__class__ is Allele, f'Expected parse("A*31:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_58():
    result = parse("A*31:58")
    assert result.__class__ is Allele, f'Expected parse("A*31:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_59():
    result = parse("A*31:59")
    assert result.__class__ is Allele, f'Expected parse("A*31:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_60N():
    result = parse("A*31:60N")
    assert result.__class__ is Allele, f'Expected parse("A*31:60N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:60N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_61():
    result = parse("A*31:61")
    assert result.__class__ is Allele, f'Expected parse("A*31:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_62():
    result = parse("A*31:62")
    assert result.__class__ is Allele, f'Expected parse("A*31:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_63():
    result = parse("A*31:63")
    assert result.__class__ is Allele, f'Expected parse("A*31:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_64():
    result = parse("A*31:64")
    assert result.__class__ is Allele, f'Expected parse("A*31:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_65():
    result = parse("A*31:65")
    assert result.__class__ is Allele, f'Expected parse("A*31:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_66():
    result = parse("A*31:66")
    assert result.__class__ is Allele, f'Expected parse("A*31:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_67():
    result = parse("A*31:67")
    assert result.__class__ is Allele, f'Expected parse("A*31:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_68():
    result = parse("A*31:68")
    assert result.__class__ is Allele, f'Expected parse("A*31:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_69():
    result = parse("A*31:69")
    assert result.__class__ is Allele, f'Expected parse("A*31:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_70():
    result = parse("A*31:70")
    assert result.__class__ is Allele, f'Expected parse("A*31:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_71():
    result = parse("A*31:71")
    assert result.__class__ is Allele, f'Expected parse("A*31:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_72():
    result = parse("A*31:72")
    assert result.__class__ is Allele, f'Expected parse("A*31:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_73():
    result = parse("A*31:73")
    assert result.__class__ is Allele, f'Expected parse("A*31:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_74():
    result = parse("A*31:74")
    assert result.__class__ is Allele, f'Expected parse("A*31:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_75():
    result = parse("A*31:75")
    assert result.__class__ is Allele, f'Expected parse("A*31:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_76():
    result = parse("A*31:76")
    assert result.__class__ is Allele, f'Expected parse("A*31:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_77():
    result = parse("A*31:77")
    assert result.__class__ is Allele, f'Expected parse("A*31:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_78():
    result = parse("A*31:78")
    assert result.__class__ is Allele, f'Expected parse("A*31:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_79():
    result = parse("A*31:79")
    assert result.__class__ is Allele, f'Expected parse("A*31:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_80():
    result = parse("A*31:80")
    assert result.__class__ is Allele, f'Expected parse("A*31:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_81():
    result = parse("A*31:81")
    assert result.__class__ is Allele, f'Expected parse("A*31:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_82():
    result = parse("A*31:82")
    assert result.__class__ is Allele, f'Expected parse("A*31:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_83():
    result = parse("A*31:83")
    assert result.__class__ is Allele, f'Expected parse("A*31:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_84():
    result = parse("A*31:84")
    assert result.__class__ is Allele, f'Expected parse("A*31:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_85():
    result = parse("A*31:85")
    assert result.__class__ is Allele, f'Expected parse("A*31:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_86():
    result = parse("A*31:86")
    assert result.__class__ is Allele, f'Expected parse("A*31:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_87():
    result = parse("A*31:87")
    assert result.__class__ is Allele, f'Expected parse("A*31:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_88():
    result = parse("A*31:88")
    assert result.__class__ is Allele, f'Expected parse("A*31:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_89():
    result = parse("A*31:89")
    assert result.__class__ is Allele, f'Expected parse("A*31:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_90():
    result = parse("A*31:90")
    assert result.__class__ is Allele, f'Expected parse("A*31:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_91():
    result = parse("A*31:91")
    assert result.__class__ is Allele, f'Expected parse("A*31:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_92():
    result = parse("A*31:92")
    assert result.__class__ is Allele, f'Expected parse("A*31:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_93():
    result = parse("A*31:93")
    assert result.__class__ is Allele, f'Expected parse("A*31:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_94():
    result = parse("A*31:94")
    assert result.__class__ is Allele, f'Expected parse("A*31:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_95():
    result = parse("A*31:95")
    assert result.__class__ is Allele, f'Expected parse("A*31:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_96():
    result = parse("A*31:96")
    assert result.__class__ is Allele, f'Expected parse("A*31:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_97():
    result = parse("A*31:97")
    assert result.__class__ is Allele, f'Expected parse("A*31:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_98():
    result = parse("A*31:98")
    assert result.__class__ is Allele, f'Expected parse("A*31:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_31_99():
    result = parse("A*31:99")
    assert result.__class__ is Allele, f'Expected parse("A*31:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*31:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_01():
    result = parse("A*32:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_02():
    result = parse("A*32:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_03():
    result = parse("A*32:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_04():
    result = parse("A*32:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_05():
    result = parse("A*32:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_06():
    result = parse("A*32:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_07():
    result = parse("A*32:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_08():
    result = parse("A*32:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_09():
    result = parse("A*32:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_10():
    result = parse("A*32:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_11():
    result = parse("A*32:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_12():
    result = parse("A*32:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_13():
    result = parse("A*32:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_14():
    result = parse("A*32:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_15():
    result = parse("A*32:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_16():
    result = parse("A*32:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_17():
    result = parse("A*32:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_18():
    result = parse("A*32:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_19():
    result = parse("A*32:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_20():
    result = parse("A*32:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_21():
    result = parse("A*32:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_22():
    result = parse("A*32:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_23():
    result = parse("A*32:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_01_24():
    result = parse("A*32:01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:01:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_02():
    result = parse("A*32:01:02")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_03():
    result = parse("A*32:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_04():
    result = parse("A*32:01:04")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_05():
    result = parse("A*32:01:05")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_06():
    result = parse("A*32:01:06")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_07():
    result = parse("A*32:01:07")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_08():
    result = parse("A*32:01:08")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_09():
    result = parse("A*32:01:09")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_10():
    result = parse("A*32:01:10")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_11():
    result = parse("A*32:01:11")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_12():
    result = parse("A*32:01:12")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_13():
    result = parse("A*32:01:13")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_14():
    result = parse("A*32:01:14")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_15():
    result = parse("A*32:01:15")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_16():
    result = parse("A*32:01:16")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_17():
    result = parse("A*32:01:17")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_18():
    result = parse("A*32:01:18")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_19():
    result = parse("A*32:01:19")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_20():
    result = parse("A*32:01:20")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_21():
    result = parse("A*32:01:21")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_22():
    result = parse("A*32:01:22")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_23():
    result = parse("A*32:01:23")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_24():
    result = parse("A*32:01:24")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_25():
    result = parse("A*32:01:25")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_26():
    result = parse("A*32:01:26")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_27():
    result = parse("A*32:01:27")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_28():
    result = parse("A*32:01:28")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_29():
    result = parse("A*32:01:29")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_30():
    result = parse("A*32:01:30")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_31():
    result = parse("A*32:01:31")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_32():
    result = parse("A*32:01:32")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_33():
    result = parse("A*32:01:33")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_34():
    result = parse("A*32:01:34")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_35():
    result = parse("A*32:01:35")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_36():
    result = parse("A*32:01:36")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_37():
    result = parse("A*32:01:37")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_38():
    result = parse("A*32:01:38")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_39():
    result = parse("A*32:01:39")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_40():
    result = parse("A*32:01:40")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_41():
    result = parse("A*32:01:41")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_01_42():
    result = parse("A*32:01:42")
    assert result.__class__ is Allele, f'Expected parse("A*32:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_02():
    result = parse("A*32:02")
    assert result.__class__ is Allele, f'Expected parse("A*32:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_03_01_01():
    result = parse("A*32:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_03_01_02():
    result = parse("A*32:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_04():
    result = parse("A*32:04")
    assert result.__class__ is Allele, f'Expected parse("A*32:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_05():
    result = parse("A*32:05")
    assert result.__class__ is Allele, f'Expected parse("A*32:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_06():
    result = parse("A*32:06")
    assert result.__class__ is Allele, f'Expected parse("A*32:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_07():
    result = parse("A*32:07")
    assert result.__class__ is Allele, f'Expected parse("A*32:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_08():
    result = parse("A*32:08")
    assert result.__class__ is Allele, f'Expected parse("A*32:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_09():
    result = parse("A*32:09")
    assert result.__class__ is Allele, f'Expected parse("A*32:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_10():
    result = parse("A*32:10")
    assert result.__class__ is Allele, f'Expected parse("A*32:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_100():
    result = parse("A*32:100")
    assert result.__class__ is Allele, f'Expected parse("A*32:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_101Q():
    result = parse("A*32:101Q")
    assert result.__class__ is Allele, f'Expected parse("A*32:101Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:101Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_102():
    result = parse("A*32:102")
    assert result.__class__ is Allele, f'Expected parse("A*32:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_103():
    result = parse("A*32:103")
    assert result.__class__ is Allele, f'Expected parse("A*32:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_104():
    result = parse("A*32:104")
    assert result.__class__ is Allele, f'Expected parse("A*32:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_105():
    result = parse("A*32:105")
    assert result.__class__ is Allele, f'Expected parse("A*32:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_106_01_01():
    result = parse("A*32:106:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:106:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:106:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_106_01_02():
    result = parse("A*32:106:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*32:106:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*32:106:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_107():
    result = parse("A*32:107")
    assert result.__class__ is Allele, f'Expected parse("A*32:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_108():
    result = parse("A*32:108")
    assert result.__class__ is Allele, f'Expected parse("A*32:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_109():
    result = parse("A*32:109")
    assert result.__class__ is Allele, f'Expected parse("A*32:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_110():
    result = parse("A*32:110")
    assert result.__class__ is Allele, f'Expected parse("A*32:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_111():
    result = parse("A*32:111")
    assert result.__class__ is Allele, f'Expected parse("A*32:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_112N():
    result = parse("A*32:112N")
    assert result.__class__ is Allele, f'Expected parse("A*32:112N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:112N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_113():
    result = parse("A*32:113")
    assert result.__class__ is Allele, f'Expected parse("A*32:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_114():
    result = parse("A*32:114")
    assert result.__class__ is Allele, f'Expected parse("A*32:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_115():
    result = parse("A*32:115")
    assert result.__class__ is Allele, f'Expected parse("A*32:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_116():
    result = parse("A*32:116")
    assert result.__class__ is Allele, f'Expected parse("A*32:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_117N():
    result = parse("A*32:117N")
    assert result.__class__ is Allele, f'Expected parse("A*32:117N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:117N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_118():
    result = parse("A*32:118")
    assert result.__class__ is Allele, f'Expected parse("A*32:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_119():
    result = parse("A*32:119")
    assert result.__class__ is Allele, f'Expected parse("A*32:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_11Q():
    result = parse("A*32:11Q")
    assert result.__class__ is Allele, f'Expected parse("A*32:11Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:11Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_12():
    result = parse("A*32:12")
    assert result.__class__ is Allele, f'Expected parse("A*32:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_120():
    result = parse("A*32:120")
    assert result.__class__ is Allele, f'Expected parse("A*32:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_121():
    result = parse("A*32:121")
    assert result.__class__ is Allele, f'Expected parse("A*32:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_122():
    result = parse("A*32:122")
    assert result.__class__ is Allele, f'Expected parse("A*32:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_123():
    result = parse("A*32:123")
    assert result.__class__ is Allele, f'Expected parse("A*32:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_124():
    result = parse("A*32:124")
    assert result.__class__ is Allele, f'Expected parse("A*32:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_125():
    result = parse("A*32:125")
    assert result.__class__ is Allele, f'Expected parse("A*32:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_126N():
    result = parse("A*32:126N")
    assert result.__class__ is Allele, f'Expected parse("A*32:126N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:126N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_127():
    result = parse("A*32:127")
    assert result.__class__ is Allele, f'Expected parse("A*32:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_128():
    result = parse("A*32:128")
    assert result.__class__ is Allele, f'Expected parse("A*32:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_129():
    result = parse("A*32:129")
    assert result.__class__ is Allele, f'Expected parse("A*32:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_13():
    result = parse("A*32:13")
    assert result.__class__ is Allele, f'Expected parse("A*32:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_130N():
    result = parse("A*32:130N")
    assert result.__class__ is Allele, f'Expected parse("A*32:130N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:130N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_131():
    result = parse("A*32:131")
    assert result.__class__ is Allele, f'Expected parse("A*32:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_132N():
    result = parse("A*32:132N")
    assert result.__class__ is Allele, f'Expected parse("A*32:132N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:132N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_133N():
    result = parse("A*32:133N")
    assert result.__class__ is Allele, f'Expected parse("A*32:133N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:133N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_134():
    result = parse("A*32:134")
    assert result.__class__ is Allele, f'Expected parse("A*32:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_135N():
    result = parse("A*32:135N")
    assert result.__class__ is Allele, f'Expected parse("A*32:135N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:135N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_136():
    result = parse("A*32:136")
    assert result.__class__ is Allele, f'Expected parse("A*32:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_137():
    result = parse("A*32:137")
    assert result.__class__ is Allele, f'Expected parse("A*32:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_138():
    result = parse("A*32:138")
    assert result.__class__ is Allele, f'Expected parse("A*32:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_139():
    result = parse("A*32:139")
    assert result.__class__ is Allele, f'Expected parse("A*32:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_14():
    result = parse("A*32:14")
    assert result.__class__ is Allele, f'Expected parse("A*32:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_140():
    result = parse("A*32:140")
    assert result.__class__ is Allele, f'Expected parse("A*32:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_141():
    result = parse("A*32:141")
    assert result.__class__ is Allele, f'Expected parse("A*32:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_142():
    result = parse("A*32:142")
    assert result.__class__ is Allele, f'Expected parse("A*32:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_143():
    result = parse("A*32:143")
    assert result.__class__ is Allele, f'Expected parse("A*32:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_144():
    result = parse("A*32:144")
    assert result.__class__ is Allele, f'Expected parse("A*32:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_15():
    result = parse("A*32:15")
    assert result.__class__ is Allele, f'Expected parse("A*32:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_16():
    result = parse("A*32:16")
    assert result.__class__ is Allele, f'Expected parse("A*32:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_17():
    result = parse("A*32:17")
    assert result.__class__ is Allele, f'Expected parse("A*32:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_18():
    result = parse("A*32:18")
    assert result.__class__ is Allele, f'Expected parse("A*32:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_19N():
    result = parse("A*32:19N")
    assert result.__class__ is Allele, f'Expected parse("A*32:19N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:19N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_20():
    result = parse("A*32:20")
    assert result.__class__ is Allele, f'Expected parse("A*32:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_21():
    result = parse("A*32:21")
    assert result.__class__ is Allele, f'Expected parse("A*32:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_22():
    result = parse("A*32:22")
    assert result.__class__ is Allele, f'Expected parse("A*32:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_23():
    result = parse("A*32:23")
    assert result.__class__ is Allele, f'Expected parse("A*32:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_24():
    result = parse("A*32:24")
    assert result.__class__ is Allele, f'Expected parse("A*32:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_25():
    result = parse("A*32:25")
    assert result.__class__ is Allele, f'Expected parse("A*32:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_26_01():
    result = parse("A*32:26:01")
    assert result.__class__ is Allele, f'Expected parse("A*32:26:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:26:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_26_02():
    result = parse("A*32:26:02")
    assert result.__class__ is Allele, f'Expected parse("A*32:26:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:26:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_27N():
    result = parse("A*32:27N")
    assert result.__class__ is Allele, f'Expected parse("A*32:27N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:27N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_28():
    result = parse("A*32:28")
    assert result.__class__ is Allele, f'Expected parse("A*32:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_29():
    result = parse("A*32:29")
    assert result.__class__ is Allele, f'Expected parse("A*32:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_30_01():
    result = parse("A*32:30:01")
    assert result.__class__ is Allele, f'Expected parse("A*32:30:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:30:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_30_02():
    result = parse("A*32:30:02")
    assert result.__class__ is Allele, f'Expected parse("A*32:30:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:30:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_31():
    result = parse("A*32:31")
    assert result.__class__ is Allele, f'Expected parse("A*32:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_32():
    result = parse("A*32:32")
    assert result.__class__ is Allele, f'Expected parse("A*32:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_33_01():
    result = parse("A*32:33:01")
    assert result.__class__ is Allele, f'Expected parse("A*32:33:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:33:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_33_02():
    result = parse("A*32:33:02")
    assert result.__class__ is Allele, f'Expected parse("A*32:33:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:33:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_34():
    result = parse("A*32:34")
    assert result.__class__ is Allele, f'Expected parse("A*32:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_35():
    result = parse("A*32:35")
    assert result.__class__ is Allele, f'Expected parse("A*32:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_36():
    result = parse("A*32:36")
    assert result.__class__ is Allele, f'Expected parse("A*32:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_37():
    result = parse("A*32:37")
    assert result.__class__ is Allele, f'Expected parse("A*32:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_38():
    result = parse("A*32:38")
    assert result.__class__ is Allele, f'Expected parse("A*32:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_39():
    result = parse("A*32:39")
    assert result.__class__ is Allele, f'Expected parse("A*32:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_40():
    result = parse("A*32:40")
    assert result.__class__ is Allele, f'Expected parse("A*32:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_41():
    result = parse("A*32:41")
    assert result.__class__ is Allele, f'Expected parse("A*32:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_42():
    result = parse("A*32:42")
    assert result.__class__ is Allele, f'Expected parse("A*32:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_43_01():
    result = parse("A*32:43:01")
    assert result.__class__ is Allele, f'Expected parse("A*32:43:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:43:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_43_02():
    result = parse("A*32:43:02")
    assert result.__class__ is Allele, f'Expected parse("A*32:43:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:43:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_44():
    result = parse("A*32:44")
    assert result.__class__ is Allele, f'Expected parse("A*32:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_45N():
    result = parse("A*32:45N")
    assert result.__class__ is Allele, f'Expected parse("A*32:45N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:45N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_46():
    result = parse("A*32:46")
    assert result.__class__ is Allele, f'Expected parse("A*32:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_47():
    result = parse("A*32:47")
    assert result.__class__ is Allele, f'Expected parse("A*32:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_48N():
    result = parse("A*32:48N")
    assert result.__class__ is Allele, f'Expected parse("A*32:48N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:48N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_49():
    result = parse("A*32:49")
    assert result.__class__ is Allele, f'Expected parse("A*32:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_50():
    result = parse("A*32:50")
    assert result.__class__ is Allele, f'Expected parse("A*32:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_51():
    result = parse("A*32:51")
    assert result.__class__ is Allele, f'Expected parse("A*32:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_52():
    result = parse("A*32:52")
    assert result.__class__ is Allele, f'Expected parse("A*32:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_53():
    result = parse("A*32:53")
    assert result.__class__ is Allele, f'Expected parse("A*32:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_54():
    result = parse("A*32:54")
    assert result.__class__ is Allele, f'Expected parse("A*32:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_55_01():
    result = parse("A*32:55:01")
    assert result.__class__ is Allele, f'Expected parse("A*32:55:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:55:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_55_02():
    result = parse("A*32:55:02")
    assert result.__class__ is Allele, f'Expected parse("A*32:55:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:55:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_55_03():
    result = parse("A*32:55:03")
    assert result.__class__ is Allele, f'Expected parse("A*32:55:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*32:55:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_56N():
    result = parse("A*32:56N")
    assert result.__class__ is Allele, f'Expected parse("A*32:56N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:56N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_57():
    result = parse("A*32:57")
    assert result.__class__ is Allele, f'Expected parse("A*32:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_58():
    result = parse("A*32:58")
    assert result.__class__ is Allele, f'Expected parse("A*32:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_59():
    result = parse("A*32:59")
    assert result.__class__ is Allele, f'Expected parse("A*32:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_60():
    result = parse("A*32:60")
    assert result.__class__ is Allele, f'Expected parse("A*32:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_61():
    result = parse("A*32:61")
    assert result.__class__ is Allele, f'Expected parse("A*32:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_62():
    result = parse("A*32:62")
    assert result.__class__ is Allele, f'Expected parse("A*32:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_63():
    result = parse("A*32:63")
    assert result.__class__ is Allele, f'Expected parse("A*32:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_64():
    result = parse("A*32:64")
    assert result.__class__ is Allele, f'Expected parse("A*32:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_65():
    result = parse("A*32:65")
    assert result.__class__ is Allele, f'Expected parse("A*32:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_66():
    result = parse("A*32:66")
    assert result.__class__ is Allele, f'Expected parse("A*32:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_67():
    result = parse("A*32:67")
    assert result.__class__ is Allele, f'Expected parse("A*32:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_68():
    result = parse("A*32:68")
    assert result.__class__ is Allele, f'Expected parse("A*32:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_69():
    result = parse("A*32:69")
    assert result.__class__ is Allele, f'Expected parse("A*32:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_70():
    result = parse("A*32:70")
    assert result.__class__ is Allele, f'Expected parse("A*32:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_71():
    result = parse("A*32:71")
    assert result.__class__ is Allele, f'Expected parse("A*32:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_72():
    result = parse("A*32:72")
    assert result.__class__ is Allele, f'Expected parse("A*32:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_73():
    result = parse("A*32:73")
    assert result.__class__ is Allele, f'Expected parse("A*32:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_74():
    result = parse("A*32:74")
    assert result.__class__ is Allele, f'Expected parse("A*32:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_75():
    result = parse("A*32:75")
    assert result.__class__ is Allele, f'Expected parse("A*32:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_76():
    result = parse("A*32:76")
    assert result.__class__ is Allele, f'Expected parse("A*32:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_77():
    result = parse("A*32:77")
    assert result.__class__ is Allele, f'Expected parse("A*32:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_78():
    result = parse("A*32:78")
    assert result.__class__ is Allele, f'Expected parse("A*32:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_79():
    result = parse("A*32:79")
    assert result.__class__ is Allele, f'Expected parse("A*32:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_80():
    result = parse("A*32:80")
    assert result.__class__ is Allele, f'Expected parse("A*32:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_81():
    result = parse("A*32:81")
    assert result.__class__ is Allele, f'Expected parse("A*32:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_82():
    result = parse("A*32:82")
    assert result.__class__ is Allele, f'Expected parse("A*32:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_83():
    result = parse("A*32:83")
    assert result.__class__ is Allele, f'Expected parse("A*32:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_84():
    result = parse("A*32:84")
    assert result.__class__ is Allele, f'Expected parse("A*32:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_85():
    result = parse("A*32:85")
    assert result.__class__ is Allele, f'Expected parse("A*32:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_86():
    result = parse("A*32:86")
    assert result.__class__ is Allele, f'Expected parse("A*32:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_87():
    result = parse("A*32:87")
    assert result.__class__ is Allele, f'Expected parse("A*32:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_88():
    result = parse("A*32:88")
    assert result.__class__ is Allele, f'Expected parse("A*32:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_89():
    result = parse("A*32:89")
    assert result.__class__ is Allele, f'Expected parse("A*32:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_90():
    result = parse("A*32:90")
    assert result.__class__ is Allele, f'Expected parse("A*32:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_91():
    result = parse("A*32:91")
    assert result.__class__ is Allele, f'Expected parse("A*32:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_92N():
    result = parse("A*32:92N")
    assert result.__class__ is Allele, f'Expected parse("A*32:92N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:92N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_93():
    result = parse("A*32:93")
    assert result.__class__ is Allele, f'Expected parse("A*32:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_94():
    result = parse("A*32:94")
    assert result.__class__ is Allele, f'Expected parse("A*32:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_95():
    result = parse("A*32:95")
    assert result.__class__ is Allele, f'Expected parse("A*32:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_96():
    result = parse("A*32:96")
    assert result.__class__ is Allele, f'Expected parse("A*32:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_97():
    result = parse("A*32:97")
    assert result.__class__ is Allele, f'Expected parse("A*32:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_98():
    result = parse("A*32:98")
    assert result.__class__ is Allele, f'Expected parse("A*32:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_32_99():
    result = parse("A*32:99")
    assert result.__class__ is Allele, f'Expected parse("A*32:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*32:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_01_01():
    result = parse("A*33:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_01_02():
    result = parse("A*33:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_01_03():
    result = parse("A*33:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_01_04():
    result = parse("A*33:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_01_05():
    result = parse("A*33:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_01_06():
    result = parse("A*33:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_01_07():
    result = parse("A*33:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_01_08():
    result = parse("A*33:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_02():
    result = parse("A*33:01:02")
    assert result.__class__ is Allele, f'Expected parse("A*33:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_03():
    result = parse("A*33:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*33:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_04():
    result = parse("A*33:01:04")
    assert result.__class__ is Allele, f'Expected parse("A*33:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_05():
    result = parse("A*33:01:05")
    assert result.__class__ is Allele, f'Expected parse("A*33:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_06():
    result = parse("A*33:01:06")
    assert result.__class__ is Allele, f'Expected parse("A*33:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_07():
    result = parse("A*33:01:07")
    assert result.__class__ is Allele, f'Expected parse("A*33:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_08():
    result = parse("A*33:01:08")
    assert result.__class__ is Allele, f'Expected parse("A*33:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_09():
    result = parse("A*33:01:09")
    assert result.__class__ is Allele, f'Expected parse("A*33:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_10():
    result = parse("A*33:01:10")
    assert result.__class__ is Allele, f'Expected parse("A*33:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_11():
    result = parse("A*33:01:11")
    assert result.__class__ is Allele, f'Expected parse("A*33:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_12():
    result = parse("A*33:01:12")
    assert result.__class__ is Allele, f'Expected parse("A*33:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_13():
    result = parse("A*33:01:13")
    assert result.__class__ is Allele, f'Expected parse("A*33:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_14():
    result = parse("A*33:01:14")
    assert result.__class__ is Allele, f'Expected parse("A*33:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_01_15():
    result = parse("A*33:01:15")
    assert result.__class__ is Allele, f'Expected parse("A*33:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_01():
    result = parse("A*33:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_02():
    result = parse("A*33:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_03():
    result = parse("A*33:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_04():
    result = parse("A*33:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_05():
    result = parse("A*33:03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_06():
    result = parse("A*33:03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_07():
    result = parse("A*33:03:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_08():
    result = parse("A*33:03:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_09():
    result = parse("A*33:03:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_10():
    result = parse("A*33:03:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_11():
    result = parse("A*33:03:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_12():
    result = parse("A*33:03:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_13():
    result = parse("A*33:03:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_14():
    result = parse("A*33:03:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_15():
    result = parse("A*33:03:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_16():
    result = parse("A*33:03:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_17():
    result = parse("A*33:03:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_01_18():
    result = parse("A*33:03:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*33:03:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_02():
    result = parse("A*33:03:02")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_03Q():
    result = parse("A*33:03:03Q")
    assert result.__class__ is Allele, (
        f'Expected parse("A*33:03:03Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:03Q") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_04():
    result = parse("A*33:03:04")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_05():
    result = parse("A*33:03:05")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_06():
    result = parse("A*33:03:06")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_07():
    result = parse("A*33:03:07")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_08():
    result = parse("A*33:03:08")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_09():
    result = parse("A*33:03:09")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_10():
    result = parse("A*33:03:10")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_11():
    result = parse("A*33:03:11")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_12():
    result = parse("A*33:03:12")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_13():
    result = parse("A*33:03:13")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_14():
    result = parse("A*33:03:14")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_15():
    result = parse("A*33:03:15")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_16():
    result = parse("A*33:03:16")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_17():
    result = parse("A*33:03:17")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_18():
    result = parse("A*33:03:18")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_19():
    result = parse("A*33:03:19")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_20():
    result = parse("A*33:03:20")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_21():
    result = parse("A*33:03:21")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_22():
    result = parse("A*33:03:22")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_23():
    result = parse("A*33:03:23")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_24():
    result = parse("A*33:03:24")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_25():
    result = parse("A*33:03:25")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_26():
    result = parse("A*33:03:26")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_27():
    result = parse("A*33:03:27")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_28():
    result = parse("A*33:03:28")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_29():
    result = parse("A*33:03:29")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_30():
    result = parse("A*33:03:30")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_31():
    result = parse("A*33:03:31")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_32():
    result = parse("A*33:03:32")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_33():
    result = parse("A*33:03:33")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_34():
    result = parse("A*33:03:34")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_35():
    result = parse("A*33:03:35")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_36():
    result = parse("A*33:03:36")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_37():
    result = parse("A*33:03:37")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_38():
    result = parse("A*33:03:38")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_39():
    result = parse("A*33:03:39")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_40():
    result = parse("A*33:03:40")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_41():
    result = parse("A*33:03:41")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_42():
    result = parse("A*33:03:42")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_43():
    result = parse("A*33:03:43")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_44():
    result = parse("A*33:03:44")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_45():
    result = parse("A*33:03:45")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_03_46():
    result = parse("A*33:03:46")
    assert result.__class__ is Allele, f'Expected parse("A*33:03:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:03:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_04():
    result = parse("A*33:04")
    assert result.__class__ is Allele, f'Expected parse("A*33:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_05():
    result = parse("A*33:05")
    assert result.__class__ is Allele, f'Expected parse("A*33:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_06():
    result = parse("A*33:06")
    assert result.__class__ is Allele, f'Expected parse("A*33:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_07():
    result = parse("A*33:07")
    assert result.__class__ is Allele, f'Expected parse("A*33:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_08():
    result = parse("A*33:08")
    assert result.__class__ is Allele, f'Expected parse("A*33:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_09():
    result = parse("A*33:09")
    assert result.__class__ is Allele, f'Expected parse("A*33:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_10():
    result = parse("A*33:10")
    assert result.__class__ is Allele, f'Expected parse("A*33:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_100():
    result = parse("A*33:100")
    assert result.__class__ is Allele, f'Expected parse("A*33:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_101():
    result = parse("A*33:101")
    assert result.__class__ is Allele, f'Expected parse("A*33:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_102():
    result = parse("A*33:102")
    assert result.__class__ is Allele, f'Expected parse("A*33:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_103():
    result = parse("A*33:103")
    assert result.__class__ is Allele, f'Expected parse("A*33:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_104():
    result = parse("A*33:104")
    assert result.__class__ is Allele, f'Expected parse("A*33:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_105():
    result = parse("A*33:105")
    assert result.__class__ is Allele, f'Expected parse("A*33:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_106():
    result = parse("A*33:106")
    assert result.__class__ is Allele, f'Expected parse("A*33:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_107():
    result = parse("A*33:107")
    assert result.__class__ is Allele, f'Expected parse("A*33:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_108():
    result = parse("A*33:108")
    assert result.__class__ is Allele, f'Expected parse("A*33:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_109():
    result = parse("A*33:109")
    assert result.__class__ is Allele, f'Expected parse("A*33:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_11():
    result = parse("A*33:11")
    assert result.__class__ is Allele, f'Expected parse("A*33:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_110():
    result = parse("A*33:110")
    assert result.__class__ is Allele, f'Expected parse("A*33:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_111():
    result = parse("A*33:111")
    assert result.__class__ is Allele, f'Expected parse("A*33:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_112():
    result = parse("A*33:112")
    assert result.__class__ is Allele, f'Expected parse("A*33:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_113():
    result = parse("A*33:113")
    assert result.__class__ is Allele, f'Expected parse("A*33:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_114():
    result = parse("A*33:114")
    assert result.__class__ is Allele, f'Expected parse("A*33:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_115():
    result = parse("A*33:115")
    assert result.__class__ is Allele, f'Expected parse("A*33:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_116():
    result = parse("A*33:116")
    assert result.__class__ is Allele, f'Expected parse("A*33:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_117():
    result = parse("A*33:117")
    assert result.__class__ is Allele, f'Expected parse("A*33:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_118():
    result = parse("A*33:118")
    assert result.__class__ is Allele, f'Expected parse("A*33:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_119():
    result = parse("A*33:119")
    assert result.__class__ is Allele, f'Expected parse("A*33:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_12():
    result = parse("A*33:12")
    assert result.__class__ is Allele, f'Expected parse("A*33:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_120():
    result = parse("A*33:120")
    assert result.__class__ is Allele, f'Expected parse("A*33:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_121():
    result = parse("A*33:121")
    assert result.__class__ is Allele, f'Expected parse("A*33:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_122():
    result = parse("A*33:122")
    assert result.__class__ is Allele, f'Expected parse("A*33:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_123N():
    result = parse("A*33:123N")
    assert result.__class__ is Allele, f'Expected parse("A*33:123N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:123N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_124():
    result = parse("A*33:124")
    assert result.__class__ is Allele, f'Expected parse("A*33:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_125():
    result = parse("A*33:125")
    assert result.__class__ is Allele, f'Expected parse("A*33:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_126():
    result = parse("A*33:126")
    assert result.__class__ is Allele, f'Expected parse("A*33:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_127():
    result = parse("A*33:127")
    assert result.__class__ is Allele, f'Expected parse("A*33:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_128():
    result = parse("A*33:128")
    assert result.__class__ is Allele, f'Expected parse("A*33:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_129N():
    result = parse("A*33:129N")
    assert result.__class__ is Allele, f'Expected parse("A*33:129N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:129N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_13():
    result = parse("A*33:13")
    assert result.__class__ is Allele, f'Expected parse("A*33:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_130():
    result = parse("A*33:130")
    assert result.__class__ is Allele, f'Expected parse("A*33:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_131():
    result = parse("A*33:131")
    assert result.__class__ is Allele, f'Expected parse("A*33:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_132():
    result = parse("A*33:132")
    assert result.__class__ is Allele, f'Expected parse("A*33:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_133():
    result = parse("A*33:133")
    assert result.__class__ is Allele, f'Expected parse("A*33:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_134():
    result = parse("A*33:134")
    assert result.__class__ is Allele, f'Expected parse("A*33:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_135():
    result = parse("A*33:135")
    assert result.__class__ is Allele, f'Expected parse("A*33:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_136():
    result = parse("A*33:136")
    assert result.__class__ is Allele, f'Expected parse("A*33:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_137():
    result = parse("A*33:137")
    assert result.__class__ is Allele, f'Expected parse("A*33:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_138():
    result = parse("A*33:138")
    assert result.__class__ is Allele, f'Expected parse("A*33:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_139():
    result = parse("A*33:139")
    assert result.__class__ is Allele, f'Expected parse("A*33:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_14():
    result = parse("A*33:14")
    assert result.__class__ is Allele, f'Expected parse("A*33:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_140N():
    result = parse("A*33:140N")
    assert result.__class__ is Allele, f'Expected parse("A*33:140N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:140N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_141():
    result = parse("A*33:141")
    assert result.__class__ is Allele, f'Expected parse("A*33:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_142():
    result = parse("A*33:142")
    assert result.__class__ is Allele, f'Expected parse("A*33:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_143N():
    result = parse("A*33:143N")
    assert result.__class__ is Allele, f'Expected parse("A*33:143N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:143N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_144():
    result = parse("A*33:144")
    assert result.__class__ is Allele, f'Expected parse("A*33:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_145():
    result = parse("A*33:145")
    assert result.__class__ is Allele, f'Expected parse("A*33:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_146():
    result = parse("A*33:146")
    assert result.__class__ is Allele, f'Expected parse("A*33:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_147():
    result = parse("A*33:147")
    assert result.__class__ is Allele, f'Expected parse("A*33:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_148():
    result = parse("A*33:148")
    assert result.__class__ is Allele, f'Expected parse("A*33:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_149():
    result = parse("A*33:149")
    assert result.__class__ is Allele, f'Expected parse("A*33:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_15():
    result = parse("A*33:15")
    assert result.__class__ is Allele, f'Expected parse("A*33:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_150():
    result = parse("A*33:150")
    assert result.__class__ is Allele, f'Expected parse("A*33:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_151():
    result = parse("A*33:151")
    assert result.__class__ is Allele, f'Expected parse("A*33:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_152():
    result = parse("A*33:152")
    assert result.__class__ is Allele, f'Expected parse("A*33:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_153():
    result = parse("A*33:153")
    assert result.__class__ is Allele, f'Expected parse("A*33:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_154N():
    result = parse("A*33:154N")
    assert result.__class__ is Allele, f'Expected parse("A*33:154N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:154N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_155():
    result = parse("A*33:155")
    assert result.__class__ is Allele, f'Expected parse("A*33:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_156N():
    result = parse("A*33:156N")
    assert result.__class__ is Allele, f'Expected parse("A*33:156N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:156N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_157N():
    result = parse("A*33:157N")
    assert result.__class__ is Allele, f'Expected parse("A*33:157N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:157N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_158():
    result = parse("A*33:158")
    assert result.__class__ is Allele, f'Expected parse("A*33:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_159():
    result = parse("A*33:159")
    assert result.__class__ is Allele, f'Expected parse("A*33:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_16():
    result = parse("A*33:16")
    assert result.__class__ is Allele, f'Expected parse("A*33:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_160():
    result = parse("A*33:160")
    assert result.__class__ is Allele, f'Expected parse("A*33:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_161():
    result = parse("A*33:161")
    assert result.__class__ is Allele, f'Expected parse("A*33:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_162():
    result = parse("A*33:162")
    assert result.__class__ is Allele, f'Expected parse("A*33:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_163():
    result = parse("A*33:163")
    assert result.__class__ is Allele, f'Expected parse("A*33:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_164():
    result = parse("A*33:164")
    assert result.__class__ is Allele, f'Expected parse("A*33:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_165():
    result = parse("A*33:165")
    assert result.__class__ is Allele, f'Expected parse("A*33:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_166():
    result = parse("A*33:166")
    assert result.__class__ is Allele, f'Expected parse("A*33:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_167():
    result = parse("A*33:167")
    assert result.__class__ is Allele, f'Expected parse("A*33:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_168():
    result = parse("A*33:168")
    assert result.__class__ is Allele, f'Expected parse("A*33:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_169():
    result = parse("A*33:169")
    assert result.__class__ is Allele, f'Expected parse("A*33:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_17():
    result = parse("A*33:17")
    assert result.__class__ is Allele, f'Expected parse("A*33:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_170():
    result = parse("A*33:170")
    assert result.__class__ is Allele, f'Expected parse("A*33:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_171():
    result = parse("A*33:171")
    assert result.__class__ is Allele, f'Expected parse("A*33:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_172():
    result = parse("A*33:172")
    assert result.__class__ is Allele, f'Expected parse("A*33:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_173():
    result = parse("A*33:173")
    assert result.__class__ is Allele, f'Expected parse("A*33:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_174N():
    result = parse("A*33:174N")
    assert result.__class__ is Allele, f'Expected parse("A*33:174N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:174N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_175Q():
    result = parse("A*33:175Q")
    assert result.__class__ is Allele, f'Expected parse("A*33:175Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:175Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_176N():
    result = parse("A*33:176N")
    assert result.__class__ is Allele, f'Expected parse("A*33:176N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:176N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_177():
    result = parse("A*33:177")
    assert result.__class__ is Allele, f'Expected parse("A*33:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_178():
    result = parse("A*33:178")
    assert result.__class__ is Allele, f'Expected parse("A*33:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_179():
    result = parse("A*33:179")
    assert result.__class__ is Allele, f'Expected parse("A*33:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_180():
    result = parse("A*33:180")
    assert result.__class__ is Allele, f'Expected parse("A*33:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_181():
    result = parse("A*33:181")
    assert result.__class__ is Allele, f'Expected parse("A*33:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_182():
    result = parse("A*33:182")
    assert result.__class__ is Allele, f'Expected parse("A*33:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_183():
    result = parse("A*33:183")
    assert result.__class__ is Allele, f'Expected parse("A*33:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_184():
    result = parse("A*33:184")
    assert result.__class__ is Allele, f'Expected parse("A*33:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_185():
    result = parse("A*33:185")
    assert result.__class__ is Allele, f'Expected parse("A*33:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_186():
    result = parse("A*33:186")
    assert result.__class__ is Allele, f'Expected parse("A*33:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_187():
    result = parse("A*33:187")
    assert result.__class__ is Allele, f'Expected parse("A*33:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_188():
    result = parse("A*33:188")
    assert result.__class__ is Allele, f'Expected parse("A*33:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_189():
    result = parse("A*33:189")
    assert result.__class__ is Allele, f'Expected parse("A*33:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_18_01():
    result = parse("A*33:18:01")
    assert result.__class__ is Allele, f'Expected parse("A*33:18:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:18:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_18_02():
    result = parse("A*33:18:02")
    assert result.__class__ is Allele, f'Expected parse("A*33:18:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:18:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_19():
    result = parse("A*33:19")
    assert result.__class__ is Allele, f'Expected parse("A*33:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_190():
    result = parse("A*33:190")
    assert result.__class__ is Allele, f'Expected parse("A*33:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_191():
    result = parse("A*33:191")
    assert result.__class__ is Allele, f'Expected parse("A*33:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_192():
    result = parse("A*33:192")
    assert result.__class__ is Allele, f'Expected parse("A*33:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_193():
    result = parse("A*33:193")
    assert result.__class__ is Allele, f'Expected parse("A*33:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_194N():
    result = parse("A*33:194N")
    assert result.__class__ is Allele, f'Expected parse("A*33:194N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:194N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_195():
    result = parse("A*33:195")
    assert result.__class__ is Allele, f'Expected parse("A*33:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_196():
    result = parse("A*33:196")
    assert result.__class__ is Allele, f'Expected parse("A*33:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_197():
    result = parse("A*33:197")
    assert result.__class__ is Allele, f'Expected parse("A*33:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_198N():
    result = parse("A*33:198N")
    assert result.__class__ is Allele, f'Expected parse("A*33:198N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:198N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_199():
    result = parse("A*33:199")
    assert result.__class__ is Allele, f'Expected parse("A*33:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_20():
    result = parse("A*33:20")
    assert result.__class__ is Allele, f'Expected parse("A*33:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_200():
    result = parse("A*33:200")
    assert result.__class__ is Allele, f'Expected parse("A*33:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_201():
    result = parse("A*33:201")
    assert result.__class__ is Allele, f'Expected parse("A*33:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_202():
    result = parse("A*33:202")
    assert result.__class__ is Allele, f'Expected parse("A*33:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_203():
    result = parse("A*33:203")
    assert result.__class__ is Allele, f'Expected parse("A*33:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_204():
    result = parse("A*33:204")
    assert result.__class__ is Allele, f'Expected parse("A*33:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_205():
    result = parse("A*33:205")
    assert result.__class__ is Allele, f'Expected parse("A*33:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_206():
    result = parse("A*33:206")
    assert result.__class__ is Allele, f'Expected parse("A*33:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_21():
    result = parse("A*33:21")
    assert result.__class__ is Allele, f'Expected parse("A*33:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_22():
    result = parse("A*33:22")
    assert result.__class__ is Allele, f'Expected parse("A*33:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_23():
    result = parse("A*33:23")
    assert result.__class__ is Allele, f'Expected parse("A*33:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_24():
    result = parse("A*33:24")
    assert result.__class__ is Allele, f'Expected parse("A*33:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_25():
    result = parse("A*33:25")
    assert result.__class__ is Allele, f'Expected parse("A*33:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_26():
    result = parse("A*33:26")
    assert result.__class__ is Allele, f'Expected parse("A*33:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_27():
    result = parse("A*33:27")
    assert result.__class__ is Allele, f'Expected parse("A*33:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_28():
    result = parse("A*33:28")
    assert result.__class__ is Allele, f'Expected parse("A*33:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_29():
    result = parse("A*33:29")
    assert result.__class__ is Allele, f'Expected parse("A*33:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_30():
    result = parse("A*33:30")
    assert result.__class__ is Allele, f'Expected parse("A*33:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_31():
    result = parse("A*33:31")
    assert result.__class__ is Allele, f'Expected parse("A*33:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_32_01():
    result = parse("A*33:32:01")
    assert result.__class__ is Allele, f'Expected parse("A*33:32:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:32:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_32_02():
    result = parse("A*33:32:02")
    assert result.__class__ is Allele, f'Expected parse("A*33:32:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:32:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_33():
    result = parse("A*33:33")
    assert result.__class__ is Allele, f'Expected parse("A*33:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_34():
    result = parse("A*33:34")
    assert result.__class__ is Allele, f'Expected parse("A*33:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_35():
    result = parse("A*33:35")
    assert result.__class__ is Allele, f'Expected parse("A*33:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_36():
    result = parse("A*33:36")
    assert result.__class__ is Allele, f'Expected parse("A*33:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_37():
    result = parse("A*33:37")
    assert result.__class__ is Allele, f'Expected parse("A*33:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_39():
    result = parse("A*33:39")
    assert result.__class__ is Allele, f'Expected parse("A*33:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_40_01():
    result = parse("A*33:40:01")
    assert result.__class__ is Allele, f'Expected parse("A*33:40:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:40:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_40_02():
    result = parse("A*33:40:02")
    assert result.__class__ is Allele, f'Expected parse("A*33:40:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*33:40:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_41():
    result = parse("A*33:41")
    assert result.__class__ is Allele, f'Expected parse("A*33:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_42():
    result = parse("A*33:42")
    assert result.__class__ is Allele, f'Expected parse("A*33:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_43():
    result = parse("A*33:43")
    assert result.__class__ is Allele, f'Expected parse("A*33:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_44():
    result = parse("A*33:44")
    assert result.__class__ is Allele, f'Expected parse("A*33:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_45():
    result = parse("A*33:45")
    assert result.__class__ is Allele, f'Expected parse("A*33:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_46():
    result = parse("A*33:46")
    assert result.__class__ is Allele, f'Expected parse("A*33:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_47():
    result = parse("A*33:47")
    assert result.__class__ is Allele, f'Expected parse("A*33:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_48():
    result = parse("A*33:48")
    assert result.__class__ is Allele, f'Expected parse("A*33:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_49():
    result = parse("A*33:49")
    assert result.__class__ is Allele, f'Expected parse("A*33:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_50():
    result = parse("A*33:50")
    assert result.__class__ is Allele, f'Expected parse("A*33:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_51():
    result = parse("A*33:51")
    assert result.__class__ is Allele, f'Expected parse("A*33:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_52():
    result = parse("A*33:52")
    assert result.__class__ is Allele, f'Expected parse("A*33:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_53():
    result = parse("A*33:53")
    assert result.__class__ is Allele, f'Expected parse("A*33:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_54():
    result = parse("A*33:54")
    assert result.__class__ is Allele, f'Expected parse("A*33:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_55():
    result = parse("A*33:55")
    assert result.__class__ is Allele, f'Expected parse("A*33:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_56():
    result = parse("A*33:56")
    assert result.__class__ is Allele, f'Expected parse("A*33:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_57():
    result = parse("A*33:57")
    assert result.__class__ is Allele, f'Expected parse("A*33:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_58():
    result = parse("A*33:58")
    assert result.__class__ is Allele, f'Expected parse("A*33:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_59():
    result = parse("A*33:59")
    assert result.__class__ is Allele, f'Expected parse("A*33:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_60():
    result = parse("A*33:60")
    assert result.__class__ is Allele, f'Expected parse("A*33:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_61():
    result = parse("A*33:61")
    assert result.__class__ is Allele, f'Expected parse("A*33:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_62():
    result = parse("A*33:62")
    assert result.__class__ is Allele, f'Expected parse("A*33:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_63():
    result = parse("A*33:63")
    assert result.__class__ is Allele, f'Expected parse("A*33:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_64():
    result = parse("A*33:64")
    assert result.__class__ is Allele, f'Expected parse("A*33:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_65():
    result = parse("A*33:65")
    assert result.__class__ is Allele, f'Expected parse("A*33:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_66():
    result = parse("A*33:66")
    assert result.__class__ is Allele, f'Expected parse("A*33:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_67():
    result = parse("A*33:67")
    assert result.__class__ is Allele, f'Expected parse("A*33:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_68():
    result = parse("A*33:68")
    assert result.__class__ is Allele, f'Expected parse("A*33:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_69():
    result = parse("A*33:69")
    assert result.__class__ is Allele, f'Expected parse("A*33:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_70():
    result = parse("A*33:70")
    assert result.__class__ is Allele, f'Expected parse("A*33:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_71():
    result = parse("A*33:71")
    assert result.__class__ is Allele, f'Expected parse("A*33:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_72():
    result = parse("A*33:72")
    assert result.__class__ is Allele, f'Expected parse("A*33:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_73N():
    result = parse("A*33:73N")
    assert result.__class__ is Allele, f'Expected parse("A*33:73N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:73N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_74N():
    result = parse("A*33:74N")
    assert result.__class__ is Allele, f'Expected parse("A*33:74N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:74N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_75():
    result = parse("A*33:75")
    assert result.__class__ is Allele, f'Expected parse("A*33:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_76():
    result = parse("A*33:76")
    assert result.__class__ is Allele, f'Expected parse("A*33:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_77():
    result = parse("A*33:77")
    assert result.__class__ is Allele, f'Expected parse("A*33:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_78():
    result = parse("A*33:78")
    assert result.__class__ is Allele, f'Expected parse("A*33:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_79():
    result = parse("A*33:79")
    assert result.__class__ is Allele, f'Expected parse("A*33:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_80N():
    result = parse("A*33:80N")
    assert result.__class__ is Allele, f'Expected parse("A*33:80N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:80N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_81():
    result = parse("A*33:81")
    assert result.__class__ is Allele, f'Expected parse("A*33:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_82():
    result = parse("A*33:82")
    assert result.__class__ is Allele, f'Expected parse("A*33:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_83():
    result = parse("A*33:83")
    assert result.__class__ is Allele, f'Expected parse("A*33:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_84():
    result = parse("A*33:84")
    assert result.__class__ is Allele, f'Expected parse("A*33:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_85():
    result = parse("A*33:85")
    assert result.__class__ is Allele, f'Expected parse("A*33:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_86():
    result = parse("A*33:86")
    assert result.__class__ is Allele, f'Expected parse("A*33:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_87():
    result = parse("A*33:87")
    assert result.__class__ is Allele, f'Expected parse("A*33:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_88():
    result = parse("A*33:88")
    assert result.__class__ is Allele, f'Expected parse("A*33:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_89():
    result = parse("A*33:89")
    assert result.__class__ is Allele, f'Expected parse("A*33:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_90():
    result = parse("A*33:90")
    assert result.__class__ is Allele, f'Expected parse("A*33:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_91():
    result = parse("A*33:91")
    assert result.__class__ is Allele, f'Expected parse("A*33:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_92():
    result = parse("A*33:92")
    assert result.__class__ is Allele, f'Expected parse("A*33:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_93():
    result = parse("A*33:93")
    assert result.__class__ is Allele, f'Expected parse("A*33:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_94():
    result = parse("A*33:94")
    assert result.__class__ is Allele, f'Expected parse("A*33:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_95():
    result = parse("A*33:95")
    assert result.__class__ is Allele, f'Expected parse("A*33:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_96N():
    result = parse("A*33:96N")
    assert result.__class__ is Allele, f'Expected parse("A*33:96N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:96N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_97():
    result = parse("A*33:97")
    assert result.__class__ is Allele, f'Expected parse("A*33:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_98():
    result = parse("A*33:98")
    assert result.__class__ is Allele, f'Expected parse("A*33:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_33_99():
    result = parse("A*33:99")
    assert result.__class__ is Allele, f'Expected parse("A*33:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*33:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_01_01_01():
    result = parse("A*34:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*34:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*34:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_01_01_02():
    result = parse("A*34:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*34:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*34:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_01_01_03():
    result = parse("A*34:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*34:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*34:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_01_02():
    result = parse("A*34:01:02")
    assert result.__class__ is Allele, f'Expected parse("A*34:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*34:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_01_03():
    result = parse("A*34:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*34:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*34:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_01_04():
    result = parse("A*34:01:04")
    assert result.__class__ is Allele, f'Expected parse("A*34:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*34:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_01_05():
    result = parse("A*34:01:05")
    assert result.__class__ is Allele, f'Expected parse("A*34:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*34:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_02_01_01():
    result = parse("A*34:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*34:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*34:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_02_01_02():
    result = parse("A*34:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*34:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*34:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_02_01_03():
    result = parse("A*34:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*34:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*34:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_02_02():
    result = parse("A*34:02:02")
    assert result.__class__ is Allele, f'Expected parse("A*34:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*34:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_02_03():
    result = parse("A*34:02:03")
    assert result.__class__ is Allele, f'Expected parse("A*34:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*34:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_02_04():
    result = parse("A*34:02:04")
    assert result.__class__ is Allele, f'Expected parse("A*34:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*34:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_02_05():
    result = parse("A*34:02:05")
    assert result.__class__ is Allele, f'Expected parse("A*34:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*34:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_02_06():
    result = parse("A*34:02:06")
    assert result.__class__ is Allele, f'Expected parse("A*34:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*34:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_03():
    result = parse("A*34:03")
    assert result.__class__ is Allele, f'Expected parse("A*34:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_04():
    result = parse("A*34:04")
    assert result.__class__ is Allele, f'Expected parse("A*34:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_05():
    result = parse("A*34:05")
    assert result.__class__ is Allele, f'Expected parse("A*34:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_06():
    result = parse("A*34:06")
    assert result.__class__ is Allele, f'Expected parse("A*34:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_07():
    result = parse("A*34:07")
    assert result.__class__ is Allele, f'Expected parse("A*34:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_08():
    result = parse("A*34:08")
    assert result.__class__ is Allele, f'Expected parse("A*34:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_09():
    result = parse("A*34:09")
    assert result.__class__ is Allele, f'Expected parse("A*34:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_10N():
    result = parse("A*34:10N")
    assert result.__class__ is Allele, f'Expected parse("A*34:10N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:10N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_11():
    result = parse("A*34:11")
    assert result.__class__ is Allele, f'Expected parse("A*34:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_12():
    result = parse("A*34:12")
    assert result.__class__ is Allele, f'Expected parse("A*34:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_13():
    result = parse("A*34:13")
    assert result.__class__ is Allele, f'Expected parse("A*34:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_14():
    result = parse("A*34:14")
    assert result.__class__ is Allele, f'Expected parse("A*34:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_15():
    result = parse("A*34:15")
    assert result.__class__ is Allele, f'Expected parse("A*34:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_16():
    result = parse("A*34:16")
    assert result.__class__ is Allele, f'Expected parse("A*34:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_17():
    result = parse("A*34:17")
    assert result.__class__ is Allele, f'Expected parse("A*34:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_18():
    result = parse("A*34:18")
    assert result.__class__ is Allele, f'Expected parse("A*34:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_19():
    result = parse("A*34:19")
    assert result.__class__ is Allele, f'Expected parse("A*34:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_20():
    result = parse("A*34:20")
    assert result.__class__ is Allele, f'Expected parse("A*34:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_21():
    result = parse("A*34:21")
    assert result.__class__ is Allele, f'Expected parse("A*34:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_22():
    result = parse("A*34:22")
    assert result.__class__ is Allele, f'Expected parse("A*34:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_34_23():
    result = parse("A*34:23")
    assert result.__class__ is Allele, f'Expected parse("A*34:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*34:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_36_01_01_01():
    result = parse("A*36:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*36:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*36:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_36_01_01_02():
    result = parse("A*36:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*36:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*36:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_36_02():
    result = parse("A*36:02")
    assert result.__class__ is Allele, f'Expected parse("A*36:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*36:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_36_03():
    result = parse("A*36:03")
    assert result.__class__ is Allele, f'Expected parse("A*36:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*36:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_36_04():
    result = parse("A*36:04")
    assert result.__class__ is Allele, f'Expected parse("A*36:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*36:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_36_05():
    result = parse("A*36:05")
    assert result.__class__ is Allele, f'Expected parse("A*36:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*36:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_36_06():
    result = parse("A*36:06")
    assert result.__class__ is Allele, f'Expected parse("A*36:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*36:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_36_07():
    result = parse("A*36:07")
    assert result.__class__ is Allele, f'Expected parse("A*36:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*36:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_36_08():
    result = parse("A*36:08")
    assert result.__class__ is Allele, f'Expected parse("A*36:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*36:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_36_09():
    result = parse("A*36:09")
    assert result.__class__ is Allele, f'Expected parse("A*36:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*36:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_36_10():
    result = parse("A*36:10")
    assert result.__class__ is Allele, f'Expected parse("A*36:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*36:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_36_11():
    result = parse("A*36:11")
    assert result.__class__ is Allele, f'Expected parse("A*36:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*36:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_43_01():
    result = parse("A*43:01")
    assert result.__class__ is Allele, f'Expected parse("A*43:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*43:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_43_02N():
    result = parse("A*43:02N")
    assert result.__class__ is Allele, f'Expected parse("A*43:02N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*43:02N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_01_01_01():
    result = parse("A*66:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*66:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*66:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_01_01_02():
    result = parse("A*66:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*66:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*66:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_01_01_03():
    result = parse("A*66:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*66:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*66:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_01_01_04():
    result = parse("A*66:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*66:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*66:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_01_01_05():
    result = parse("A*66:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*66:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*66:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_01_02():
    result = parse("A*66:01:02")
    assert result.__class__ is Allele, f'Expected parse("A*66:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*66:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_01_03():
    result = parse("A*66:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*66:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*66:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_01_04():
    result = parse("A*66:01:04")
    assert result.__class__ is Allele, f'Expected parse("A*66:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*66:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_01_05():
    result = parse("A*66:01:05")
    assert result.__class__ is Allele, f'Expected parse("A*66:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*66:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_02():
    result = parse("A*66:02")
    assert result.__class__ is Allele, f'Expected parse("A*66:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_03_01_01():
    result = parse("A*66:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*66:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*66:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_03_01_02():
    result = parse("A*66:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*66:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*66:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_03_01_03():
    result = parse("A*66:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*66:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*66:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_04():
    result = parse("A*66:04")
    assert result.__class__ is Allele, f'Expected parse("A*66:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_05():
    result = parse("A*66:05")
    assert result.__class__ is Allele, f'Expected parse("A*66:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_06():
    result = parse("A*66:06")
    assert result.__class__ is Allele, f'Expected parse("A*66:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_07():
    result = parse("A*66:07")
    assert result.__class__ is Allele, f'Expected parse("A*66:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_08():
    result = parse("A*66:08")
    assert result.__class__ is Allele, f'Expected parse("A*66:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_09():
    result = parse("A*66:09")
    assert result.__class__ is Allele, f'Expected parse("A*66:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_10():
    result = parse("A*66:10")
    assert result.__class__ is Allele, f'Expected parse("A*66:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_11():
    result = parse("A*66:11")
    assert result.__class__ is Allele, f'Expected parse("A*66:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_12():
    result = parse("A*66:12")
    assert result.__class__ is Allele, f'Expected parse("A*66:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_13():
    result = parse("A*66:13")
    assert result.__class__ is Allele, f'Expected parse("A*66:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_14():
    result = parse("A*66:14")
    assert result.__class__ is Allele, f'Expected parse("A*66:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_15():
    result = parse("A*66:15")
    assert result.__class__ is Allele, f'Expected parse("A*66:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_16():
    result = parse("A*66:16")
    assert result.__class__ is Allele, f'Expected parse("A*66:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_17():
    result = parse("A*66:17")
    assert result.__class__ is Allele, f'Expected parse("A*66:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_18():
    result = parse("A*66:18")
    assert result.__class__ is Allele, f'Expected parse("A*66:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_19():
    result = parse("A*66:19")
    assert result.__class__ is Allele, f'Expected parse("A*66:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_20():
    result = parse("A*66:20")
    assert result.__class__ is Allele, f'Expected parse("A*66:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_21():
    result = parse("A*66:21")
    assert result.__class__ is Allele, f'Expected parse("A*66:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_22():
    result = parse("A*66:22")
    assert result.__class__ is Allele, f'Expected parse("A*66:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_23():
    result = parse("A*66:23")
    assert result.__class__ is Allele, f'Expected parse("A*66:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_24():
    result = parse("A*66:24")
    assert result.__class__ is Allele, f'Expected parse("A*66:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_25():
    result = parse("A*66:25")
    assert result.__class__ is Allele, f'Expected parse("A*66:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_26Q():
    result = parse("A*66:26Q")
    assert result.__class__ is Allele, f'Expected parse("A*66:26Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:26Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_27N():
    result = parse("A*66:27N")
    assert result.__class__ is Allele, f'Expected parse("A*66:27N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:27N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_28N():
    result = parse("A*66:28N")
    assert result.__class__ is Allele, f'Expected parse("A*66:28N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:28N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_29():
    result = parse("A*66:29")
    assert result.__class__ is Allele, f'Expected parse("A*66:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_30():
    result = parse("A*66:30")
    assert result.__class__ is Allele, f'Expected parse("A*66:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_31():
    result = parse("A*66:31")
    assert result.__class__ is Allele, f'Expected parse("A*66:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_32():
    result = parse("A*66:32")
    assert result.__class__ is Allele, f'Expected parse("A*66:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_33():
    result = parse("A*66:33")
    assert result.__class__ is Allele, f'Expected parse("A*66:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_34():
    result = parse("A*66:34")
    assert result.__class__ is Allele, f'Expected parse("A*66:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_35():
    result = parse("A*66:35")
    assert result.__class__ is Allele, f'Expected parse("A*66:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_36():
    result = parse("A*66:36")
    assert result.__class__ is Allele, f'Expected parse("A*66:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_37():
    result = parse("A*66:37")
    assert result.__class__ is Allele, f'Expected parse("A*66:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_38():
    result = parse("A*66:38")
    assert result.__class__ is Allele, f'Expected parse("A*66:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_39N():
    result = parse("A*66:39N")
    assert result.__class__ is Allele, f'Expected parse("A*66:39N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:39N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_40():
    result = parse("A*66:40")
    assert result.__class__ is Allele, f'Expected parse("A*66:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_41():
    result = parse("A*66:41")
    assert result.__class__ is Allele, f'Expected parse("A*66:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_42():
    result = parse("A*66:42")
    assert result.__class__ is Allele, f'Expected parse("A*66:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_66_43():
    result = parse("A*66:43")
    assert result.__class__ is Allele, f'Expected parse("A*66:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*66:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_01_01():
    result = parse("A*68:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_01_02():
    result = parse("A*68:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_01_03():
    result = parse("A*68:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_01_04():
    result = parse("A*68:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_01_05():
    result = parse("A*68:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_01_06():
    result = parse("A*68:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_01_07():
    result = parse("A*68:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_01_08():
    result = parse("A*68:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_01_09():
    result = parse("A*68:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_01_10():
    result = parse("A*68:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_01():
    result = parse("A*68:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_02():
    result = parse("A*68:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_03():
    result = parse("A*68:01:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_04():
    result = parse("A*68:01:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_05():
    result = parse("A*68:01:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_06():
    result = parse("A*68:01:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_07():
    result = parse("A*68:01:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_08():
    result = parse("A*68:01:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_09():
    result = parse("A*68:01:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_10():
    result = parse("A*68:01:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_11():
    result = parse("A*68:01:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_12():
    result = parse("A*68:01:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_13():
    result = parse("A*68:01:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_14():
    result = parse("A*68:01:02:14")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_15():
    result = parse("A*68:01:02:15")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_16():
    result = parse("A*68:01:02:16")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_17():
    result = parse("A*68:01:02:17")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_18():
    result = parse("A*68:01:02:18")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_19():
    result = parse("A*68:01:02:19")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_20():
    result = parse("A*68:01:02:20")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_21():
    result = parse("A*68:01:02:21")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_02_22():
    result = parse("A*68:01:02:22")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:01:02:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:01:02:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_03():
    result = parse("A*68:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_04():
    result = parse("A*68:01:04")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_05():
    result = parse("A*68:01:05")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_06():
    result = parse("A*68:01:06")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_07():
    result = parse("A*68:01:07")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_08():
    result = parse("A*68:01:08")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_09():
    result = parse("A*68:01:09")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_10():
    result = parse("A*68:01:10")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_11():
    result = parse("A*68:01:11")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_12():
    result = parse("A*68:01:12")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_13():
    result = parse("A*68:01:13")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_14():
    result = parse("A*68:01:14")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_15():
    result = parse("A*68:01:15")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_16():
    result = parse("A*68:01:16")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_17():
    result = parse("A*68:01:17")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_18():
    result = parse("A*68:01:18")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_19():
    result = parse("A*68:01:19")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_20():
    result = parse("A*68:01:20")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_21():
    result = parse("A*68:01:21")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_22():
    result = parse("A*68:01:22")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_23():
    result = parse("A*68:01:23")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_24():
    result = parse("A*68:01:24")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_25():
    result = parse("A*68:01:25")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_26():
    result = parse("A*68:01:26")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_27():
    result = parse("A*68:01:27")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_28():
    result = parse("A*68:01:28")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_29():
    result = parse("A*68:01:29")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_30():
    result = parse("A*68:01:30")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_31():
    result = parse("A*68:01:31")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_32():
    result = parse("A*68:01:32")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_33():
    result = parse("A*68:01:33")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_34():
    result = parse("A*68:01:34")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_35():
    result = parse("A*68:01:35")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_36():
    result = parse("A*68:01:36")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_37():
    result = parse("A*68:01:37")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_38():
    result = parse("A*68:01:38")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_39():
    result = parse("A*68:01:39")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_40():
    result = parse("A*68:01:40")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_41():
    result = parse("A*68:01:41")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_42():
    result = parse("A*68:01:42")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_43():
    result = parse("A*68:01:43")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_44():
    result = parse("A*68:01:44")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_45():
    result = parse("A*68:01:45")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_46():
    result = parse("A*68:01:46")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_47():
    result = parse("A*68:01:47")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_48():
    result = parse("A*68:01:48")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_49():
    result = parse("A*68:01:49")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_50():
    result = parse("A*68:01:50")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_51():
    result = parse("A*68:01:51")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_52():
    result = parse("A*68:01:52")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_53():
    result = parse("A*68:01:53")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_54():
    result = parse("A*68:01:54")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_01_55():
    result = parse("A*68:01:55")
    assert result.__class__ is Allele, f'Expected parse("A*68:01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:01:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_01_01():
    result = parse("A*68:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_01_02():
    result = parse("A*68:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_01_03():
    result = parse("A*68:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_01_04():
    result = parse("A*68:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_01_05():
    result = parse("A*68:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_01_06():
    result = parse("A*68:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_01_07():
    result = parse("A*68:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_01_08():
    result = parse("A*68:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_01_09():
    result = parse("A*68:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_01_10():
    result = parse("A*68:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_01_11():
    result = parse("A*68:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_01_12():
    result = parse("A*68:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_02():
    result = parse("A*68:02:02")
    assert result.__class__ is Allele, f'Expected parse("A*68:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_03():
    result = parse("A*68:02:03")
    assert result.__class__ is Allele, f'Expected parse("A*68:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_04():
    result = parse("A*68:02:04")
    assert result.__class__ is Allele, f'Expected parse("A*68:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_05():
    result = parse("A*68:02:05")
    assert result.__class__ is Allele, f'Expected parse("A*68:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_06():
    result = parse("A*68:02:06")
    assert result.__class__ is Allele, f'Expected parse("A*68:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_07():
    result = parse("A*68:02:07")
    assert result.__class__ is Allele, f'Expected parse("A*68:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_08():
    result = parse("A*68:02:08")
    assert result.__class__ is Allele, f'Expected parse("A*68:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_09():
    result = parse("A*68:02:09")
    assert result.__class__ is Allele, f'Expected parse("A*68:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_10():
    result = parse("A*68:02:10")
    assert result.__class__ is Allele, f'Expected parse("A*68:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_11():
    result = parse("A*68:02:11")
    assert result.__class__ is Allele, f'Expected parse("A*68:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_12():
    result = parse("A*68:02:12")
    assert result.__class__ is Allele, f'Expected parse("A*68:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_13():
    result = parse("A*68:02:13")
    assert result.__class__ is Allele, f'Expected parse("A*68:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_14():
    result = parse("A*68:02:14")
    assert result.__class__ is Allele, f'Expected parse("A*68:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_15():
    result = parse("A*68:02:15")
    assert result.__class__ is Allele, f'Expected parse("A*68:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_02_16():
    result = parse("A*68:02:16")
    assert result.__class__ is Allele, f'Expected parse("A*68:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_03_01_01():
    result = parse("A*68:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_03_01_02():
    result = parse("A*68:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_03_01_03():
    result = parse("A*68:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_03_01_04():
    result = parse("A*68:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_03_01_05():
    result = parse("A*68:03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:03:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_03_01_06():
    result = parse("A*68:03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:03:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_03_02():
    result = parse("A*68:03:02")
    assert result.__class__ is Allele, f'Expected parse("A*68:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_03_03():
    result = parse("A*68:03:03")
    assert result.__class__ is Allele, f'Expected parse("A*68:03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_04_01():
    result = parse("A*68:04:01")
    assert result.__class__ is Allele, f'Expected parse("A*68:04:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_04_02():
    result = parse("A*68:04:02")
    assert result.__class__ is Allele, f'Expected parse("A*68:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_05():
    result = parse("A*68:05")
    assert result.__class__ is Allele, f'Expected parse("A*68:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_06():
    result = parse("A*68:06")
    assert result.__class__ is Allele, f'Expected parse("A*68:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_07():
    result = parse("A*68:07")
    assert result.__class__ is Allele, f'Expected parse("A*68:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_08_01_01():
    result = parse("A*68:08:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:08:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:08:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_08_01_02():
    result = parse("A*68:08:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:08:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:08:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_08_02():
    result = parse("A*68:08:02")
    assert result.__class__ is Allele, f'Expected parse("A*68:08:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:08:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_09():
    result = parse("A*68:09")
    assert result.__class__ is Allele, f'Expected parse("A*68:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_10():
    result = parse("A*68:10")
    assert result.__class__ is Allele, f'Expected parse("A*68:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_100():
    result = parse("A*68:100")
    assert result.__class__ is Allele, f'Expected parse("A*68:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_101_01():
    result = parse("A*68:101:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:101:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:101:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_101_02():
    result = parse("A*68:101:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:101:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:101:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_102():
    result = parse("A*68:102")
    assert result.__class__ is Allele, f'Expected parse("A*68:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_103_01():
    result = parse("A*68:103:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:103:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:103:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_103_02():
    result = parse("A*68:103:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:103:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:103:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_104_01():
    result = parse("A*68:104:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:104:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:104:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_104_02():
    result = parse("A*68:104:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:104:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:104:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_105():
    result = parse("A*68:105")
    assert result.__class__ is Allele, f'Expected parse("A*68:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_106():
    result = parse("A*68:106")
    assert result.__class__ is Allele, f'Expected parse("A*68:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_107():
    result = parse("A*68:107")
    assert result.__class__ is Allele, f'Expected parse("A*68:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_108():
    result = parse("A*68:108")
    assert result.__class__ is Allele, f'Expected parse("A*68:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_109():
    result = parse("A*68:109")
    assert result.__class__ is Allele, f'Expected parse("A*68:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_110():
    result = parse("A*68:110")
    assert result.__class__ is Allele, f'Expected parse("A*68:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_111():
    result = parse("A*68:111")
    assert result.__class__ is Allele, f'Expected parse("A*68:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_112_01():
    result = parse("A*68:112:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:112:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:112:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_112_02():
    result = parse("A*68:112:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:112:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:112:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_113_01():
    result = parse("A*68:113:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:113:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:113:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_113_02():
    result = parse("A*68:113:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:113:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:113:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_114():
    result = parse("A*68:114")
    assert result.__class__ is Allele, f'Expected parse("A*68:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_115():
    result = parse("A*68:115")
    assert result.__class__ is Allele, f'Expected parse("A*68:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_116():
    result = parse("A*68:116")
    assert result.__class__ is Allele, f'Expected parse("A*68:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_117():
    result = parse("A*68:117")
    assert result.__class__ is Allele, f'Expected parse("A*68:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_118():
    result = parse("A*68:118")
    assert result.__class__ is Allele, f'Expected parse("A*68:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_119_01():
    result = parse("A*68:119:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:119:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:119:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_119_02():
    result = parse("A*68:119:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:119:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:119:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_11N():
    result = parse("A*68:11N")
    assert result.__class__ is Allele, f'Expected parse("A*68:11N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:11N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_120N():
    result = parse("A*68:120N")
    assert result.__class__ is Allele, f'Expected parse("A*68:120N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:120N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_121_01():
    result = parse("A*68:121:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:121:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:121:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_121_02():
    result = parse("A*68:121:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:121:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:121:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_122():
    result = parse("A*68:122")
    assert result.__class__ is Allele, f'Expected parse("A*68:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_123():
    result = parse("A*68:123")
    assert result.__class__ is Allele, f'Expected parse("A*68:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_124():
    result = parse("A*68:124")
    assert result.__class__ is Allele, f'Expected parse("A*68:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_125():
    result = parse("A*68:125")
    assert result.__class__ is Allele, f'Expected parse("A*68:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_126():
    result = parse("A*68:126")
    assert result.__class__ is Allele, f'Expected parse("A*68:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_127():
    result = parse("A*68:127")
    assert result.__class__ is Allele, f'Expected parse("A*68:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_128():
    result = parse("A*68:128")
    assert result.__class__ is Allele, f'Expected parse("A*68:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_129():
    result = parse("A*68:129")
    assert result.__class__ is Allele, f'Expected parse("A*68:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_12_01():
    result = parse("A*68:12:01")
    assert result.__class__ is Allele, f'Expected parse("A*68:12:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:12:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_12_02():
    result = parse("A*68:12:02")
    assert result.__class__ is Allele, f'Expected parse("A*68:12:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:12:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_130_01():
    result = parse("A*68:130:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:130:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:130:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_130_02():
    result = parse("A*68:130:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:130:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:130:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_131():
    result = parse("A*68:131")
    assert result.__class__ is Allele, f'Expected parse("A*68:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_132():
    result = parse("A*68:132")
    assert result.__class__ is Allele, f'Expected parse("A*68:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_133():
    result = parse("A*68:133")
    assert result.__class__ is Allele, f'Expected parse("A*68:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_134():
    result = parse("A*68:134")
    assert result.__class__ is Allele, f'Expected parse("A*68:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_135():
    result = parse("A*68:135")
    assert result.__class__ is Allele, f'Expected parse("A*68:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_136():
    result = parse("A*68:136")
    assert result.__class__ is Allele, f'Expected parse("A*68:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_137():
    result = parse("A*68:137")
    assert result.__class__ is Allele, f'Expected parse("A*68:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_138():
    result = parse("A*68:138")
    assert result.__class__ is Allele, f'Expected parse("A*68:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_139():
    result = parse("A*68:139")
    assert result.__class__ is Allele, f'Expected parse("A*68:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_13_01():
    result = parse("A*68:13:01")
    assert result.__class__ is Allele, f'Expected parse("A*68:13:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:13:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_13_02():
    result = parse("A*68:13:02")
    assert result.__class__ is Allele, f'Expected parse("A*68:13:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:13:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_14():
    result = parse("A*68:14")
    assert result.__class__ is Allele, f'Expected parse("A*68:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_140():
    result = parse("A*68:140")
    assert result.__class__ is Allele, f'Expected parse("A*68:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_141():
    result = parse("A*68:141")
    assert result.__class__ is Allele, f'Expected parse("A*68:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_142N():
    result = parse("A*68:142N")
    assert result.__class__ is Allele, f'Expected parse("A*68:142N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:142N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_143():
    result = parse("A*68:143")
    assert result.__class__ is Allele, f'Expected parse("A*68:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_144():
    result = parse("A*68:144")
    assert result.__class__ is Allele, f'Expected parse("A*68:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_145():
    result = parse("A*68:145")
    assert result.__class__ is Allele, f'Expected parse("A*68:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_146():
    result = parse("A*68:146")
    assert result.__class__ is Allele, f'Expected parse("A*68:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_147():
    result = parse("A*68:147")
    assert result.__class__ is Allele, f'Expected parse("A*68:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_148Q():
    result = parse("A*68:148Q")
    assert result.__class__ is Allele, f'Expected parse("A*68:148Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:148Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_149():
    result = parse("A*68:149")
    assert result.__class__ is Allele, f'Expected parse("A*68:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_15():
    result = parse("A*68:15")
    assert result.__class__ is Allele, f'Expected parse("A*68:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_150():
    result = parse("A*68:150")
    assert result.__class__ is Allele, f'Expected parse("A*68:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_151():
    result = parse("A*68:151")
    assert result.__class__ is Allele, f'Expected parse("A*68:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_152():
    result = parse("A*68:152")
    assert result.__class__ is Allele, f'Expected parse("A*68:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_153():
    result = parse("A*68:153")
    assert result.__class__ is Allele, f'Expected parse("A*68:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_154():
    result = parse("A*68:154")
    assert result.__class__ is Allele, f'Expected parse("A*68:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_155():
    result = parse("A*68:155")
    assert result.__class__ is Allele, f'Expected parse("A*68:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_156():
    result = parse("A*68:156")
    assert result.__class__ is Allele, f'Expected parse("A*68:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_157():
    result = parse("A*68:157")
    assert result.__class__ is Allele, f'Expected parse("A*68:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_158():
    result = parse("A*68:158")
    assert result.__class__ is Allele, f'Expected parse("A*68:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_159Q():
    result = parse("A*68:159Q")
    assert result.__class__ is Allele, f'Expected parse("A*68:159Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:159Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_16():
    result = parse("A*68:16")
    assert result.__class__ is Allele, f'Expected parse("A*68:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_160():
    result = parse("A*68:160")
    assert result.__class__ is Allele, f'Expected parse("A*68:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_161():
    result = parse("A*68:161")
    assert result.__class__ is Allele, f'Expected parse("A*68:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_162():
    result = parse("A*68:162")
    assert result.__class__ is Allele, f'Expected parse("A*68:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_163():
    result = parse("A*68:163")
    assert result.__class__ is Allele, f'Expected parse("A*68:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_164():
    result = parse("A*68:164")
    assert result.__class__ is Allele, f'Expected parse("A*68:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_165():
    result = parse("A*68:165")
    assert result.__class__ is Allele, f'Expected parse("A*68:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_166():
    result = parse("A*68:166")
    assert result.__class__ is Allele, f'Expected parse("A*68:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_167():
    result = parse("A*68:167")
    assert result.__class__ is Allele, f'Expected parse("A*68:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_168():
    result = parse("A*68:168")
    assert result.__class__ is Allele, f'Expected parse("A*68:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_169():
    result = parse("A*68:169")
    assert result.__class__ is Allele, f'Expected parse("A*68:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_170():
    result = parse("A*68:170")
    assert result.__class__ is Allele, f'Expected parse("A*68:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_171_01N():
    result = parse("A*68:171:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:171:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:171:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_171_02N():
    result = parse("A*68:171:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:171:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:171:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_172():
    result = parse("A*68:172")
    assert result.__class__ is Allele, f'Expected parse("A*68:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_173():
    result = parse("A*68:173")
    assert result.__class__ is Allele, f'Expected parse("A*68:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_174():
    result = parse("A*68:174")
    assert result.__class__ is Allele, f'Expected parse("A*68:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_175():
    result = parse("A*68:175")
    assert result.__class__ is Allele, f'Expected parse("A*68:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_176():
    result = parse("A*68:176")
    assert result.__class__ is Allele, f'Expected parse("A*68:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_177():
    result = parse("A*68:177")
    assert result.__class__ is Allele, f'Expected parse("A*68:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_178():
    result = parse("A*68:178")
    assert result.__class__ is Allele, f'Expected parse("A*68:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_179():
    result = parse("A*68:179")
    assert result.__class__ is Allele, f'Expected parse("A*68:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_17_01():
    result = parse("A*68:17:01")
    assert result.__class__ is Allele, f'Expected parse("A*68:17:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:17:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_17_02():
    result = parse("A*68:17:02")
    assert result.__class__ is Allele, f'Expected parse("A*68:17:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:17:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_180():
    result = parse("A*68:180")
    assert result.__class__ is Allele, f'Expected parse("A*68:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_181N():
    result = parse("A*68:181N")
    assert result.__class__ is Allele, f'Expected parse("A*68:181N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:181N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_182N():
    result = parse("A*68:182N")
    assert result.__class__ is Allele, f'Expected parse("A*68:182N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:182N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_183():
    result = parse("A*68:183")
    assert result.__class__ is Allele, f'Expected parse("A*68:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_184():
    result = parse("A*68:184")
    assert result.__class__ is Allele, f'Expected parse("A*68:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_185():
    result = parse("A*68:185")
    assert result.__class__ is Allele, f'Expected parse("A*68:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_186():
    result = parse("A*68:186")
    assert result.__class__ is Allele, f'Expected parse("A*68:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_187():
    result = parse("A*68:187")
    assert result.__class__ is Allele, f'Expected parse("A*68:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_188():
    result = parse("A*68:188")
    assert result.__class__ is Allele, f'Expected parse("A*68:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_189():
    result = parse("A*68:189")
    assert result.__class__ is Allele, f'Expected parse("A*68:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_18N():
    result = parse("A*68:18N")
    assert result.__class__ is Allele, f'Expected parse("A*68:18N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:18N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_19():
    result = parse("A*68:19")
    assert result.__class__ is Allele, f'Expected parse("A*68:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_190():
    result = parse("A*68:190")
    assert result.__class__ is Allele, f'Expected parse("A*68:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_191():
    result = parse("A*68:191")
    assert result.__class__ is Allele, f'Expected parse("A*68:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_192():
    result = parse("A*68:192")
    assert result.__class__ is Allele, f'Expected parse("A*68:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_193():
    result = parse("A*68:193")
    assert result.__class__ is Allele, f'Expected parse("A*68:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_194():
    result = parse("A*68:194")
    assert result.__class__ is Allele, f'Expected parse("A*68:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_195():
    result = parse("A*68:195")
    assert result.__class__ is Allele, f'Expected parse("A*68:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_196():
    result = parse("A*68:196")
    assert result.__class__ is Allele, f'Expected parse("A*68:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_197():
    result = parse("A*68:197")
    assert result.__class__ is Allele, f'Expected parse("A*68:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_198():
    result = parse("A*68:198")
    assert result.__class__ is Allele, f'Expected parse("A*68:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_199N():
    result = parse("A*68:199N")
    assert result.__class__ is Allele, f'Expected parse("A*68:199N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:199N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_20():
    result = parse("A*68:20")
    assert result.__class__ is Allele, f'Expected parse("A*68:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_200():
    result = parse("A*68:200")
    assert result.__class__ is Allele, f'Expected parse("A*68:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_201():
    result = parse("A*68:201")
    assert result.__class__ is Allele, f'Expected parse("A*68:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_202():
    result = parse("A*68:202")
    assert result.__class__ is Allele, f'Expected parse("A*68:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_203N():
    result = parse("A*68:203N")
    assert result.__class__ is Allele, f'Expected parse("A*68:203N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:203N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_204():
    result = parse("A*68:204")
    assert result.__class__ is Allele, f'Expected parse("A*68:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_205N():
    result = parse("A*68:205N")
    assert result.__class__ is Allele, f'Expected parse("A*68:205N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:205N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_206():
    result = parse("A*68:206")
    assert result.__class__ is Allele, f'Expected parse("A*68:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_207():
    result = parse("A*68:207")
    assert result.__class__ is Allele, f'Expected parse("A*68:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_208():
    result = parse("A*68:208")
    assert result.__class__ is Allele, f'Expected parse("A*68:208") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_209():
    result = parse("A*68:209")
    assert result.__class__ is Allele, f'Expected parse("A*68:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_210N():
    result = parse("A*68:210N")
    assert result.__class__ is Allele, f'Expected parse("A*68:210N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:210N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_211():
    result = parse("A*68:211")
    assert result.__class__ is Allele, f'Expected parse("A*68:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_212():
    result = parse("A*68:212")
    assert result.__class__ is Allele, f'Expected parse("A*68:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_213N():
    result = parse("A*68:213N")
    assert result.__class__ is Allele, f'Expected parse("A*68:213N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:213N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_214():
    result = parse("A*68:214")
    assert result.__class__ is Allele, f'Expected parse("A*68:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_215():
    result = parse("A*68:215")
    assert result.__class__ is Allele, f'Expected parse("A*68:215") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_216N():
    result = parse("A*68:216N")
    assert result.__class__ is Allele, f'Expected parse("A*68:216N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:216N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_217():
    result = parse("A*68:217")
    assert result.__class__ is Allele, f'Expected parse("A*68:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_218():
    result = parse("A*68:218")
    assert result.__class__ is Allele, f'Expected parse("A*68:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_219():
    result = parse("A*68:219")
    assert result.__class__ is Allele, f'Expected parse("A*68:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_21_01():
    result = parse("A*68:21:01")
    assert result.__class__ is Allele, f'Expected parse("A*68:21:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:21:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_21_02():
    result = parse("A*68:21:02")
    assert result.__class__ is Allele, f'Expected parse("A*68:21:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:21:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_21_03():
    result = parse("A*68:21:03")
    assert result.__class__ is Allele, f'Expected parse("A*68:21:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:21:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_22():
    result = parse("A*68:22")
    assert result.__class__ is Allele, f'Expected parse("A*68:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_220():
    result = parse("A*68:220")
    assert result.__class__ is Allele, f'Expected parse("A*68:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_221():
    result = parse("A*68:221")
    assert result.__class__ is Allele, f'Expected parse("A*68:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_222():
    result = parse("A*68:222")
    assert result.__class__ is Allele, f'Expected parse("A*68:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_223():
    result = parse("A*68:223")
    assert result.__class__ is Allele, f'Expected parse("A*68:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_224():
    result = parse("A*68:224")
    assert result.__class__ is Allele, f'Expected parse("A*68:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_225():
    result = parse("A*68:225")
    assert result.__class__ is Allele, f'Expected parse("A*68:225") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_226():
    result = parse("A*68:226")
    assert result.__class__ is Allele, f'Expected parse("A*68:226") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_227():
    result = parse("A*68:227")
    assert result.__class__ is Allele, f'Expected parse("A*68:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_228():
    result = parse("A*68:228")
    assert result.__class__ is Allele, f'Expected parse("A*68:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_229():
    result = parse("A*68:229")
    assert result.__class__ is Allele, f'Expected parse("A*68:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_23():
    result = parse("A*68:23")
    assert result.__class__ is Allele, f'Expected parse("A*68:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_230():
    result = parse("A*68:230")
    assert result.__class__ is Allele, f'Expected parse("A*68:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_231():
    result = parse("A*68:231")
    assert result.__class__ is Allele, f'Expected parse("A*68:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_232():
    result = parse("A*68:232")
    assert result.__class__ is Allele, f'Expected parse("A*68:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_233():
    result = parse("A*68:233")
    assert result.__class__ is Allele, f'Expected parse("A*68:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_234():
    result = parse("A*68:234")
    assert result.__class__ is Allele, f'Expected parse("A*68:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_235():
    result = parse("A*68:235")
    assert result.__class__ is Allele, f'Expected parse("A*68:235") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_236N():
    result = parse("A*68:236N")
    assert result.__class__ is Allele, f'Expected parse("A*68:236N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:236N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_237():
    result = parse("A*68:237")
    assert result.__class__ is Allele, f'Expected parse("A*68:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_238():
    result = parse("A*68:238")
    assert result.__class__ is Allele, f'Expected parse("A*68:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_239():
    result = parse("A*68:239")
    assert result.__class__ is Allele, f'Expected parse("A*68:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_24():
    result = parse("A*68:24")
    assert result.__class__ is Allele, f'Expected parse("A*68:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_240():
    result = parse("A*68:240")
    assert result.__class__ is Allele, f'Expected parse("A*68:240") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_241():
    result = parse("A*68:241")
    assert result.__class__ is Allele, f'Expected parse("A*68:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_242():
    result = parse("A*68:242")
    assert result.__class__ is Allele, f'Expected parse("A*68:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_243():
    result = parse("A*68:243")
    assert result.__class__ is Allele, f'Expected parse("A*68:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_244():
    result = parse("A*68:244")
    assert result.__class__ is Allele, f'Expected parse("A*68:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_245N():
    result = parse("A*68:245N")
    assert result.__class__ is Allele, f'Expected parse("A*68:245N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:245N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_246():
    result = parse("A*68:246")
    assert result.__class__ is Allele, f'Expected parse("A*68:246") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_247():
    result = parse("A*68:247")
    assert result.__class__ is Allele, f'Expected parse("A*68:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_248():
    result = parse("A*68:248")
    assert result.__class__ is Allele, f'Expected parse("A*68:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_25():
    result = parse("A*68:25")
    assert result.__class__ is Allele, f'Expected parse("A*68:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_26():
    result = parse("A*68:26")
    assert result.__class__ is Allele, f'Expected parse("A*68:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_27_01():
    result = parse("A*68:27:01")
    assert result.__class__ is Allele, f'Expected parse("A*68:27:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:27:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_27_02():
    result = parse("A*68:27:02")
    assert result.__class__ is Allele, f'Expected parse("A*68:27:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:27:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_28():
    result = parse("A*68:28")
    assert result.__class__ is Allele, f'Expected parse("A*68:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_29():
    result = parse("A*68:29")
    assert result.__class__ is Allele, f'Expected parse("A*68:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_30():
    result = parse("A*68:30")
    assert result.__class__ is Allele, f'Expected parse("A*68:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_31():
    result = parse("A*68:31")
    assert result.__class__ is Allele, f'Expected parse("A*68:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_32():
    result = parse("A*68:32")
    assert result.__class__ is Allele, f'Expected parse("A*68:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_33():
    result = parse("A*68:33")
    assert result.__class__ is Allele, f'Expected parse("A*68:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_34():
    result = parse("A*68:34")
    assert result.__class__ is Allele, f'Expected parse("A*68:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_35_01_01():
    result = parse("A*68:35:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:35:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:35:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_35_01_02():
    result = parse("A*68:35:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*68:35:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*68:35:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_36():
    result = parse("A*68:36")
    assert result.__class__ is Allele, f'Expected parse("A*68:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_37():
    result = parse("A*68:37")
    assert result.__class__ is Allele, f'Expected parse("A*68:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_38():
    result = parse("A*68:38")
    assert result.__class__ is Allele, f'Expected parse("A*68:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_39():
    result = parse("A*68:39")
    assert result.__class__ is Allele, f'Expected parse("A*68:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_40():
    result = parse("A*68:40")
    assert result.__class__ is Allele, f'Expected parse("A*68:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_41():
    result = parse("A*68:41")
    assert result.__class__ is Allele, f'Expected parse("A*68:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_42():
    result = parse("A*68:42")
    assert result.__class__ is Allele, f'Expected parse("A*68:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_43_01():
    result = parse("A*68:43:01")
    assert result.__class__ is Allele, f'Expected parse("A*68:43:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:43:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_43_02():
    result = parse("A*68:43:02")
    assert result.__class__ is Allele, f'Expected parse("A*68:43:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:43:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_44():
    result = parse("A*68:44")
    assert result.__class__ is Allele, f'Expected parse("A*68:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_45():
    result = parse("A*68:45")
    assert result.__class__ is Allele, f'Expected parse("A*68:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_46():
    result = parse("A*68:46")
    assert result.__class__ is Allele, f'Expected parse("A*68:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_47():
    result = parse("A*68:47")
    assert result.__class__ is Allele, f'Expected parse("A*68:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_48():
    result = parse("A*68:48")
    assert result.__class__ is Allele, f'Expected parse("A*68:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_49N():
    result = parse("A*68:49N")
    assert result.__class__ is Allele, f'Expected parse("A*68:49N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:49N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_50_01():
    result = parse("A*68:50:01")
    assert result.__class__ is Allele, f'Expected parse("A*68:50:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:50:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_50_02():
    result = parse("A*68:50:02")
    assert result.__class__ is Allele, f'Expected parse("A*68:50:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:50:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_51():
    result = parse("A*68:51")
    assert result.__class__ is Allele, f'Expected parse("A*68:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_52():
    result = parse("A*68:52")
    assert result.__class__ is Allele, f'Expected parse("A*68:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_53():
    result = parse("A*68:53")
    assert result.__class__ is Allele, f'Expected parse("A*68:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_54():
    result = parse("A*68:54")
    assert result.__class__ is Allele, f'Expected parse("A*68:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_55_01():
    result = parse("A*68:55:01")
    assert result.__class__ is Allele, f'Expected parse("A*68:55:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:55:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_55_02():
    result = parse("A*68:55:02")
    assert result.__class__ is Allele, f'Expected parse("A*68:55:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:55:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_56():
    result = parse("A*68:56")
    assert result.__class__ is Allele, f'Expected parse("A*68:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_57():
    result = parse("A*68:57")
    assert result.__class__ is Allele, f'Expected parse("A*68:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_58_01():
    result = parse("A*68:58:01")
    assert result.__class__ is Allele, f'Expected parse("A*68:58:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:58:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_58_02():
    result = parse("A*68:58:02")
    assert result.__class__ is Allele, f'Expected parse("A*68:58:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:58:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_59N():
    result = parse("A*68:59N")
    assert result.__class__ is Allele, f'Expected parse("A*68:59N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:59N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_60():
    result = parse("A*68:60")
    assert result.__class__ is Allele, f'Expected parse("A*68:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_61():
    result = parse("A*68:61")
    assert result.__class__ is Allele, f'Expected parse("A*68:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_62():
    result = parse("A*68:62")
    assert result.__class__ is Allele, f'Expected parse("A*68:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_63():
    result = parse("A*68:63")
    assert result.__class__ is Allele, f'Expected parse("A*68:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_64():
    result = parse("A*68:64")
    assert result.__class__ is Allele, f'Expected parse("A*68:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_65():
    result = parse("A*68:65")
    assert result.__class__ is Allele, f'Expected parse("A*68:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_66_01():
    result = parse("A*68:66:01")
    assert result.__class__ is Allele, f'Expected parse("A*68:66:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:66:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_66_02():
    result = parse("A*68:66:02")
    assert result.__class__ is Allele, f'Expected parse("A*68:66:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:66:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_67():
    result = parse("A*68:67")
    assert result.__class__ is Allele, f'Expected parse("A*68:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_68():
    result = parse("A*68:68")
    assert result.__class__ is Allele, f'Expected parse("A*68:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_69():
    result = parse("A*68:69")
    assert result.__class__ is Allele, f'Expected parse("A*68:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_70():
    result = parse("A*68:70")
    assert result.__class__ is Allele, f'Expected parse("A*68:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_71():
    result = parse("A*68:71")
    assert result.__class__ is Allele, f'Expected parse("A*68:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_72():
    result = parse("A*68:72")
    assert result.__class__ is Allele, f'Expected parse("A*68:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_73():
    result = parse("A*68:73")
    assert result.__class__ is Allele, f'Expected parse("A*68:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_74():
    result = parse("A*68:74")
    assert result.__class__ is Allele, f'Expected parse("A*68:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_75_01():
    result = parse("A*68:75:01")
    assert result.__class__ is Allele, f'Expected parse("A*68:75:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:75:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_75_02():
    result = parse("A*68:75:02")
    assert result.__class__ is Allele, f'Expected parse("A*68:75:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:75:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_76_01():
    result = parse("A*68:76:01")
    assert result.__class__ is Allele, f'Expected parse("A*68:76:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:76:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_76_02():
    result = parse("A*68:76:02")
    assert result.__class__ is Allele, f'Expected parse("A*68:76:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*68:76:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_77():
    result = parse("A*68:77")
    assert result.__class__ is Allele, f'Expected parse("A*68:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_78():
    result = parse("A*68:78")
    assert result.__class__ is Allele, f'Expected parse("A*68:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_79():
    result = parse("A*68:79")
    assert result.__class__ is Allele, f'Expected parse("A*68:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_80():
    result = parse("A*68:80")
    assert result.__class__ is Allele, f'Expected parse("A*68:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_81():
    result = parse("A*68:81")
    assert result.__class__ is Allele, f'Expected parse("A*68:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_82():
    result = parse("A*68:82")
    assert result.__class__ is Allele, f'Expected parse("A*68:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_83():
    result = parse("A*68:83")
    assert result.__class__ is Allele, f'Expected parse("A*68:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_84():
    result = parse("A*68:84")
    assert result.__class__ is Allele, f'Expected parse("A*68:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_85():
    result = parse("A*68:85")
    assert result.__class__ is Allele, f'Expected parse("A*68:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_86():
    result = parse("A*68:86")
    assert result.__class__ is Allele, f'Expected parse("A*68:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_87():
    result = parse("A*68:87")
    assert result.__class__ is Allele, f'Expected parse("A*68:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_88():
    result = parse("A*68:88")
    assert result.__class__ is Allele, f'Expected parse("A*68:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_89():
    result = parse("A*68:89")
    assert result.__class__ is Allele, f'Expected parse("A*68:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_90():
    result = parse("A*68:90")
    assert result.__class__ is Allele, f'Expected parse("A*68:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_91():
    result = parse("A*68:91")
    assert result.__class__ is Allele, f'Expected parse("A*68:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_92():
    result = parse("A*68:92")
    assert result.__class__ is Allele, f'Expected parse("A*68:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_93():
    result = parse("A*68:93")
    assert result.__class__ is Allele, f'Expected parse("A*68:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_94N():
    result = parse("A*68:94N")
    assert result.__class__ is Allele, f'Expected parse("A*68:94N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:94N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_95():
    result = parse("A*68:95")
    assert result.__class__ is Allele, f'Expected parse("A*68:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_96():
    result = parse("A*68:96")
    assert result.__class__ is Allele, f'Expected parse("A*68:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_97():
    result = parse("A*68:97")
    assert result.__class__ is Allele, f'Expected parse("A*68:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_98():
    result = parse("A*68:98")
    assert result.__class__ is Allele, f'Expected parse("A*68:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_68_99():
    result = parse("A*68:99")
    assert result.__class__ is Allele, f'Expected parse("A*68:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*68:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_69_01_01_01():
    result = parse("A*69:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*69:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*69:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_69_01_01_02():
    result = parse("A*69:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*69:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*69:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_69_01_01_03():
    result = parse("A*69:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*69:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*69:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_69_01_02():
    result = parse("A*69:01:02")
    assert result.__class__ is Allele, f'Expected parse("A*69:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*69:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_69_01_03():
    result = parse("A*69:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*69:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*69:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_69_02():
    result = parse("A*69:02")
    assert result.__class__ is Allele, f'Expected parse("A*69:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*69:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_69_03():
    result = parse("A*69:03")
    assert result.__class__ is Allele, f'Expected parse("A*69:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*69:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_69_04():
    result = parse("A*69:04")
    assert result.__class__ is Allele, f'Expected parse("A*69:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*69:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_69_05():
    result = parse("A*69:05")
    assert result.__class__ is Allele, f'Expected parse("A*69:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*69:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_69_06():
    result = parse("A*69:06")
    assert result.__class__ is Allele, f'Expected parse("A*69:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*69:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_69_07():
    result = parse("A*69:07")
    assert result.__class__ is Allele, f'Expected parse("A*69:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*69:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_69_08():
    result = parse("A*69:08")
    assert result.__class__ is Allele, f'Expected parse("A*69:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*69:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_01_01_01():
    result = parse("A*74:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*74:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*74:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_01_01_02():
    result = parse("A*74:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*74:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*74:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_01_01_03():
    result = parse("A*74:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("A*74:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*74:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_01_01_04():
    result = parse("A*74:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("A*74:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*74:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_01_01_05():
    result = parse("A*74:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("A*74:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*74:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_01_01_06():
    result = parse("A*74:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("A*74:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*74:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_01_01_07():
    result = parse("A*74:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("A*74:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*74:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_01_02():
    result = parse("A*74:01:02")
    assert result.__class__ is Allele, f'Expected parse("A*74:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*74:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_01_03():
    result = parse("A*74:01:03")
    assert result.__class__ is Allele, f'Expected parse("A*74:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*74:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_01_04():
    result = parse("A*74:01:04")
    assert result.__class__ is Allele, f'Expected parse("A*74:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*74:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_01_05():
    result = parse("A*74:01:05")
    assert result.__class__ is Allele, f'Expected parse("A*74:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*74:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_01_06():
    result = parse("A*74:01:06")
    assert result.__class__ is Allele, f'Expected parse("A*74:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*74:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_01_07():
    result = parse("A*74:01:07")
    assert result.__class__ is Allele, f'Expected parse("A*74:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*74:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_01_08():
    result = parse("A*74:01:08")
    assert result.__class__ is Allele, f'Expected parse("A*74:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*74:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_02_01_01():
    result = parse("A*74:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*74:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*74:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_02_01_02():
    result = parse("A*74:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*74:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*74:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_03_01_01():
    result = parse("A*74:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*74:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*74:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_03_01_02():
    result = parse("A*74:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*74:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*74:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_03_02():
    result = parse("A*74:03:02")
    assert result.__class__ is Allele, f'Expected parse("A*74:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*74:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_04():
    result = parse("A*74:04")
    assert result.__class__ is Allele, f'Expected parse("A*74:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_05():
    result = parse("A*74:05")
    assert result.__class__ is Allele, f'Expected parse("A*74:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_06():
    result = parse("A*74:06")
    assert result.__class__ is Allele, f'Expected parse("A*74:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_07():
    result = parse("A*74:07")
    assert result.__class__ is Allele, f'Expected parse("A*74:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_08():
    result = parse("A*74:08")
    assert result.__class__ is Allele, f'Expected parse("A*74:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_09():
    result = parse("A*74:09")
    assert result.__class__ is Allele, f'Expected parse("A*74:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_10():
    result = parse("A*74:10")
    assert result.__class__ is Allele, f'Expected parse("A*74:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_11():
    result = parse("A*74:11")
    assert result.__class__ is Allele, f'Expected parse("A*74:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_12N():
    result = parse("A*74:12N")
    assert result.__class__ is Allele, f'Expected parse("A*74:12N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:12N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_13():
    result = parse("A*74:13")
    assert result.__class__ is Allele, f'Expected parse("A*74:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_14N():
    result = parse("A*74:14N")
    assert result.__class__ is Allele, f'Expected parse("A*74:14N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:14N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_15():
    result = parse("A*74:15")
    assert result.__class__ is Allele, f'Expected parse("A*74:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_16_01():
    result = parse("A*74:16:01")
    assert result.__class__ is Allele, f'Expected parse("A*74:16:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*74:16:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_16_02():
    result = parse("A*74:16:02")
    assert result.__class__ is Allele, f'Expected parse("A*74:16:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*74:16:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_17():
    result = parse("A*74:17")
    assert result.__class__ is Allele, f'Expected parse("A*74:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_18():
    result = parse("A*74:18")
    assert result.__class__ is Allele, f'Expected parse("A*74:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_19():
    result = parse("A*74:19")
    assert result.__class__ is Allele, f'Expected parse("A*74:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_20():
    result = parse("A*74:20")
    assert result.__class__ is Allele, f'Expected parse("A*74:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_21():
    result = parse("A*74:21")
    assert result.__class__ is Allele, f'Expected parse("A*74:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_22():
    result = parse("A*74:22")
    assert result.__class__ is Allele, f'Expected parse("A*74:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_23():
    result = parse("A*74:23")
    assert result.__class__ is Allele, f'Expected parse("A*74:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_24():
    result = parse("A*74:24")
    assert result.__class__ is Allele, f'Expected parse("A*74:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_25():
    result = parse("A*74:25")
    assert result.__class__ is Allele, f'Expected parse("A*74:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_26():
    result = parse("A*74:26")
    assert result.__class__ is Allele, f'Expected parse("A*74:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_27():
    result = parse("A*74:27")
    assert result.__class__ is Allele, f'Expected parse("A*74:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_28():
    result = parse("A*74:28")
    assert result.__class__ is Allele, f'Expected parse("A*74:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_29():
    result = parse("A*74:29")
    assert result.__class__ is Allele, f'Expected parse("A*74:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_30():
    result = parse("A*74:30")
    assert result.__class__ is Allele, f'Expected parse("A*74:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_31():
    result = parse("A*74:31")
    assert result.__class__ is Allele, f'Expected parse("A*74:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_32N():
    result = parse("A*74:32N")
    assert result.__class__ is Allele, f'Expected parse("A*74:32N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:32N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_33():
    result = parse("A*74:33")
    assert result.__class__ is Allele, f'Expected parse("A*74:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_34():
    result = parse("A*74:34")
    assert result.__class__ is Allele, f'Expected parse("A*74:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_35():
    result = parse("A*74:35")
    assert result.__class__ is Allele, f'Expected parse("A*74:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_36():
    result = parse("A*74:36")
    assert result.__class__ is Allele, f'Expected parse("A*74:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_37():
    result = parse("A*74:37")
    assert result.__class__ is Allele, f'Expected parse("A*74:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_38():
    result = parse("A*74:38")
    assert result.__class__ is Allele, f'Expected parse("A*74:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_74_39():
    result = parse("A*74:39")
    assert result.__class__ is Allele, f'Expected parse("A*74:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*74:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_80_01_01_01():
    result = parse("A*80:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("A*80:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*80:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_80_01_01_02():
    result = parse("A*80:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("A*80:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("A*80:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_80_01_02():
    result = parse("A*80:01:02")
    assert result.__class__ is Allele, f'Expected parse("A*80:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("A*80:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_80_02():
    result = parse("A*80:02")
    assert result.__class__ is Allele, f'Expected parse("A*80:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*80:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_80_03():
    result = parse("A*80:03")
    assert result.__class__ is Allele, f'Expected parse("A*80:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*80:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_80_04():
    result = parse("A*80:04")
    assert result.__class__ is Allele, f'Expected parse("A*80:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*80:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_80_05():
    result = parse("A*80:05")
    assert result.__class__ is Allele, f'Expected parse("A*80:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*80:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_80_06():
    result = parse("A*80:06")
    assert result.__class__ is Allele, f'Expected parse("A*80:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*80:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_A_80_07():
    result = parse("A*80:07")
    assert result.__class__ is Allele, f'Expected parse("A*80:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("A*80:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_01():
    result = parse("B*07:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_02():
    result = parse("B*07:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_03():
    result = parse("B*07:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_04():
    result = parse("B*07:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_05():
    result = parse("B*07:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_06():
    result = parse("B*07:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_07():
    result = parse("B*07:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_08():
    result = parse("B*07:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_09():
    result = parse("B*07:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_10():
    result = parse("B*07:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_11():
    result = parse("B*07:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_12():
    result = parse("B*07:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_13():
    result = parse("B*07:02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_14():
    result = parse("B*07:02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_15():
    result = parse("B*07:02:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_16():
    result = parse("B*07:02:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_17():
    result = parse("B*07:02:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_18():
    result = parse("B*07:02:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_19():
    result = parse("B*07:02:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_20():
    result = parse("B*07:02:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_21():
    result = parse("B*07:02:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_22():
    result = parse("B*07:02:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_23():
    result = parse("B*07:02:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_24():
    result = parse("B*07:02:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_25():
    result = parse("B*07:02:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_26():
    result = parse("B*07:02:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_27():
    result = parse("B*07:02:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_28():
    result = parse("B*07:02:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_29():
    result = parse("B*07:02:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_30():
    result = parse("B*07:02:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_31():
    result = parse("B*07:02:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_32():
    result = parse("B*07:02:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_33():
    result = parse("B*07:02:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_34():
    result = parse("B*07:02:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_35():
    result = parse("B*07:02:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_36():
    result = parse("B*07:02:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_37():
    result = parse("B*07:02:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_38():
    result = parse("B*07:02:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_39():
    result = parse("B*07:02:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_40():
    result = parse("B*07:02:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_41():
    result = parse("B*07:02:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_42():
    result = parse("B*07:02:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_43():
    result = parse("B*07:02:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_44():
    result = parse("B*07:02:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_45():
    result = parse("B*07:02:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:45") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_46():
    result = parse("B*07:02:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:46") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_47():
    result = parse("B*07:02:01:47")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:47") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_48():
    result = parse("B*07:02:01:48")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:48") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:48") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_49():
    result = parse("B*07:02:01:49")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:49") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:49") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_50():
    result = parse("B*07:02:01:50")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:50") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:50") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_51():
    result = parse("B*07:02:01:51")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:51") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:51") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_52():
    result = parse("B*07:02:01:52")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:52") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:52") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_53():
    result = parse("B*07:02:01:53")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:53") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:53") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_54():
    result = parse("B*07:02:01:54")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:54") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:54") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_55():
    result = parse("B*07:02:01:55")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:55") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:55") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_56():
    result = parse("B*07:02:01:56")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:56") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:56") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_57():
    result = parse("B*07:02:01:57")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:57") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:57") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_58():
    result = parse("B*07:02:01:58")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:58") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:58") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_59():
    result = parse("B*07:02:01:59")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:59") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:59") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_60():
    result = parse("B*07:02:01:60")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:60") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:60") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_61():
    result = parse("B*07:02:01:61")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:61") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:61") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_62():
    result = parse("B*07:02:01:62")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:62") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:62") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_63():
    result = parse("B*07:02:01:63")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:63") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:63") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_64():
    result = parse("B*07:02:01:64")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:64") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:64") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_65():
    result = parse("B*07:02:01:65")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:65") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:65") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_66():
    result = parse("B*07:02:01:66")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:66") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:66") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_67():
    result = parse("B*07:02:01:67")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:67") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:67") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_68():
    result = parse("B*07:02:01:68")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:68") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:68") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_01_69():
    result = parse("B*07:02:01:69")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:02:01:69") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:02:01:69") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_02():
    result = parse("B*07:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_03():
    result = parse("B*07:02:03")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_04():
    result = parse("B*07:02:04")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_05():
    result = parse("B*07:02:05")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_06():
    result = parse("B*07:02:06")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_07():
    result = parse("B*07:02:07")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_08():
    result = parse("B*07:02:08")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_09():
    result = parse("B*07:02:09")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_10():
    result = parse("B*07:02:10")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_11():
    result = parse("B*07:02:11")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_12():
    result = parse("B*07:02:12")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_13():
    result = parse("B*07:02:13")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_14():
    result = parse("B*07:02:14")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_15():
    result = parse("B*07:02:15")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_16():
    result = parse("B*07:02:16")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_17():
    result = parse("B*07:02:17")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_18():
    result = parse("B*07:02:18")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_19():
    result = parse("B*07:02:19")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_20():
    result = parse("B*07:02:20")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_21():
    result = parse("B*07:02:21")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_22():
    result = parse("B*07:02:22")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_23():
    result = parse("B*07:02:23")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_24():
    result = parse("B*07:02:24")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_25():
    result = parse("B*07:02:25")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_26():
    result = parse("B*07:02:26")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_27():
    result = parse("B*07:02:27")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_28():
    result = parse("B*07:02:28")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_29():
    result = parse("B*07:02:29")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_30():
    result = parse("B*07:02:30")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_31():
    result = parse("B*07:02:31")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_32():
    result = parse("B*07:02:32")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_33():
    result = parse("B*07:02:33")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_34():
    result = parse("B*07:02:34")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_35():
    result = parse("B*07:02:35")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_36():
    result = parse("B*07:02:36")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_37():
    result = parse("B*07:02:37")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_38():
    result = parse("B*07:02:38")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_39():
    result = parse("B*07:02:39")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_40():
    result = parse("B*07:02:40")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_41():
    result = parse("B*07:02:41")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_42():
    result = parse("B*07:02:42")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_43():
    result = parse("B*07:02:43")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_44():
    result = parse("B*07:02:44")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_45():
    result = parse("B*07:02:45")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_46():
    result = parse("B*07:02:46")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_47():
    result = parse("B*07:02:47")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_48():
    result = parse("B*07:02:48")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_49():
    result = parse("B*07:02:49")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_50():
    result = parse("B*07:02:50")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_51():
    result = parse("B*07:02:51")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_52():
    result = parse("B*07:02:52")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_53():
    result = parse("B*07:02:53")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_54():
    result = parse("B*07:02:54")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_55():
    result = parse("B*07:02:55")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_56():
    result = parse("B*07:02:56")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_57():
    result = parse("B*07:02:57")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_58():
    result = parse("B*07:02:58")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_59():
    result = parse("B*07:02:59")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_60():
    result = parse("B*07:02:60")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_61():
    result = parse("B*07:02:61")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_62():
    result = parse("B*07:02:62")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_63():
    result = parse("B*07:02:63")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_64():
    result = parse("B*07:02:64")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_65():
    result = parse("B*07:02:65")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_66():
    result = parse("B*07:02:66")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:66") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:66") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_67():
    result = parse("B*07:02:67")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:67") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:67") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_68():
    result = parse("B*07:02:68")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:68") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:68") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_69():
    result = parse("B*07:02:69")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:69") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:69") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_70():
    result = parse("B*07:02:70")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:70") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:70") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_71():
    result = parse("B*07:02:71")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:71") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:71") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_72():
    result = parse("B*07:02:72")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:72") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:72") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_73():
    result = parse("B*07:02:73")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:73") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:73") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_74():
    result = parse("B*07:02:74")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:74") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:74") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_75():
    result = parse("B*07:02:75")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:75") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:75") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_76():
    result = parse("B*07:02:76")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:76") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:76") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_77():
    result = parse("B*07:02:77")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:77") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:77") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_78():
    result = parse("B*07:02:78")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:78") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:78") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_79():
    result = parse("B*07:02:79")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:79") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:79") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_80():
    result = parse("B*07:02:80")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:80") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:80") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_02_81():
    result = parse("B*07:02:81")
    assert result.__class__ is Allele, f'Expected parse("B*07:02:81") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:02:81") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_03():
    result = parse("B*07:03")
    assert result.__class__ is Allele, f'Expected parse("B*07:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_04_01():
    result = parse("B*07:04:01")
    assert result.__class__ is Allele, f'Expected parse("B*07:04:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_04_02():
    result = parse("B*07:04:02")
    assert result.__class__ is Allele, f'Expected parse("B*07:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_05_01_01():
    result = parse("B*07:05:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:05:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:05:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_05_01_02():
    result = parse("B*07:05:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:05:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:05:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_05_01_03():
    result = parse("B*07:05:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:05:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:05:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_05_01_04():
    result = parse("B*07:05:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:05:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:05:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_05_02():
    result = parse("B*07:05:02")
    assert result.__class__ is Allele, f'Expected parse("B*07:05:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_05_03():
    result = parse("B*07:05:03")
    assert result.__class__ is Allele, f'Expected parse("B*07:05:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:05:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_05_04():
    result = parse("B*07:05:04")
    assert result.__class__ is Allele, f'Expected parse("B*07:05:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:05:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_05_05():
    result = parse("B*07:05:05")
    assert result.__class__ is Allele, f'Expected parse("B*07:05:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:05:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_05_06():
    result = parse("B*07:05:06")
    assert result.__class__ is Allele, f'Expected parse("B*07:05:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:05:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_05_07():
    result = parse("B*07:05:07")
    assert result.__class__ is Allele, f'Expected parse("B*07:05:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:05:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_05_08():
    result = parse("B*07:05:08")
    assert result.__class__ is Allele, f'Expected parse("B*07:05:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:05:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_05_09():
    result = parse("B*07:05:09")
    assert result.__class__ is Allele, f'Expected parse("B*07:05:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:05:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_05_10():
    result = parse("B*07:05:10")
    assert result.__class__ is Allele, f'Expected parse("B*07:05:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:05:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_06_01_01():
    result = parse("B*07:06:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:06:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:06:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_06_01_02():
    result = parse("B*07:06:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:06:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:06:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_06_01_03():
    result = parse("B*07:06:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:06:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:06:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_06_02():
    result = parse("B*07:06:02")
    assert result.__class__ is Allele, f'Expected parse("B*07:06:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_06_03():
    result = parse("B*07:06:03")
    assert result.__class__ is Allele, f'Expected parse("B*07:06:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:06:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_06_04():
    result = parse("B*07:06:04")
    assert result.__class__ is Allele, f'Expected parse("B*07:06:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:06:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_06_05():
    result = parse("B*07:06:05")
    assert result.__class__ is Allele, f'Expected parse("B*07:06:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:06:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_07_01():
    result = parse("B*07:07:01")
    assert result.__class__ is Allele, f'Expected parse("B*07:07:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_07_02():
    result = parse("B*07:07:02")
    assert result.__class__ is Allele, f'Expected parse("B*07:07:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_07_03():
    result = parse("B*07:07:03")
    assert result.__class__ is Allele, f'Expected parse("B*07:07:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:07:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_08_01():
    result = parse("B*07:08:01")
    assert result.__class__ is Allele, f'Expected parse("B*07:08:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:08:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_08_02():
    result = parse("B*07:08:02")
    assert result.__class__ is Allele, f'Expected parse("B*07:08:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:08:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_09_01():
    result = parse("B*07:09:01")
    assert result.__class__ is Allele, f'Expected parse("B*07:09:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:09:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_09_02():
    result = parse("B*07:09:02")
    assert result.__class__ is Allele, f'Expected parse("B*07:09:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:09:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_10():
    result = parse("B*07:10")
    assert result.__class__ is Allele, f'Expected parse("B*07:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_100():
    result = parse("B*07:100")
    assert result.__class__ is Allele, f'Expected parse("B*07:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_101():
    result = parse("B*07:101")
    assert result.__class__ is Allele, f'Expected parse("B*07:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_102():
    result = parse("B*07:102")
    assert result.__class__ is Allele, f'Expected parse("B*07:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_103():
    result = parse("B*07:103")
    assert result.__class__ is Allele, f'Expected parse("B*07:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_104():
    result = parse("B*07:104")
    assert result.__class__ is Allele, f'Expected parse("B*07:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_105():
    result = parse("B*07:105")
    assert result.__class__ is Allele, f'Expected parse("B*07:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_106():
    result = parse("B*07:106")
    assert result.__class__ is Allele, f'Expected parse("B*07:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_107():
    result = parse("B*07:107")
    assert result.__class__ is Allele, f'Expected parse("B*07:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_108():
    result = parse("B*07:108")
    assert result.__class__ is Allele, f'Expected parse("B*07:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_109():
    result = parse("B*07:109")
    assert result.__class__ is Allele, f'Expected parse("B*07:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_11():
    result = parse("B*07:11")
    assert result.__class__ is Allele, f'Expected parse("B*07:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_110():
    result = parse("B*07:110")
    assert result.__class__ is Allele, f'Expected parse("B*07:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_111N():
    result = parse("B*07:111N")
    assert result.__class__ is Allele, f'Expected parse("B*07:111N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:111N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_112():
    result = parse("B*07:112")
    assert result.__class__ is Allele, f'Expected parse("B*07:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_113():
    result = parse("B*07:113")
    assert result.__class__ is Allele, f'Expected parse("B*07:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_114():
    result = parse("B*07:114")
    assert result.__class__ is Allele, f'Expected parse("B*07:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_115():
    result = parse("B*07:115")
    assert result.__class__ is Allele, f'Expected parse("B*07:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_116():
    result = parse("B*07:116")
    assert result.__class__ is Allele, f'Expected parse("B*07:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_117():
    result = parse("B*07:117")
    assert result.__class__ is Allele, f'Expected parse("B*07:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_118():
    result = parse("B*07:118")
    assert result.__class__ is Allele, f'Expected parse("B*07:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_119():
    result = parse("B*07:119")
    assert result.__class__ is Allele, f'Expected parse("B*07:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_12():
    result = parse("B*07:12")
    assert result.__class__ is Allele, f'Expected parse("B*07:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_120():
    result = parse("B*07:120")
    assert result.__class__ is Allele, f'Expected parse("B*07:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_121():
    result = parse("B*07:121")
    assert result.__class__ is Allele, f'Expected parse("B*07:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_122():
    result = parse("B*07:122")
    assert result.__class__ is Allele, f'Expected parse("B*07:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_123():
    result = parse("B*07:123")
    assert result.__class__ is Allele, f'Expected parse("B*07:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_124():
    result = parse("B*07:124")
    assert result.__class__ is Allele, f'Expected parse("B*07:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_125():
    result = parse("B*07:125")
    assert result.__class__ is Allele, f'Expected parse("B*07:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_126():
    result = parse("B*07:126")
    assert result.__class__ is Allele, f'Expected parse("B*07:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_127():
    result = parse("B*07:127")
    assert result.__class__ is Allele, f'Expected parse("B*07:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_128():
    result = parse("B*07:128")
    assert result.__class__ is Allele, f'Expected parse("B*07:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_129():
    result = parse("B*07:129")
    assert result.__class__ is Allele, f'Expected parse("B*07:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_13():
    result = parse("B*07:13")
    assert result.__class__ is Allele, f'Expected parse("B*07:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_130():
    result = parse("B*07:130")
    assert result.__class__ is Allele, f'Expected parse("B*07:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_131():
    result = parse("B*07:131")
    assert result.__class__ is Allele, f'Expected parse("B*07:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_132():
    result = parse("B*07:132")
    assert result.__class__ is Allele, f'Expected parse("B*07:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_133():
    result = parse("B*07:133")
    assert result.__class__ is Allele, f'Expected parse("B*07:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_134():
    result = parse("B*07:134")
    assert result.__class__ is Allele, f'Expected parse("B*07:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_135N():
    result = parse("B*07:135N")
    assert result.__class__ is Allele, f'Expected parse("B*07:135N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:135N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_136_01():
    result = parse("B*07:136:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:136:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:136:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_136_02():
    result = parse("B*07:136:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:136:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:136:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_137():
    result = parse("B*07:137")
    assert result.__class__ is Allele, f'Expected parse("B*07:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_138():
    result = parse("B*07:138")
    assert result.__class__ is Allele, f'Expected parse("B*07:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_139_01():
    result = parse("B*07:139:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:139:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:139:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_139_02():
    result = parse("B*07:139:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:139:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:139:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_140():
    result = parse("B*07:140")
    assert result.__class__ is Allele, f'Expected parse("B*07:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_141():
    result = parse("B*07:141")
    assert result.__class__ is Allele, f'Expected parse("B*07:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_142():
    result = parse("B*07:142")
    assert result.__class__ is Allele, f'Expected parse("B*07:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_143():
    result = parse("B*07:143")
    assert result.__class__ is Allele, f'Expected parse("B*07:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_144():
    result = parse("B*07:144")
    assert result.__class__ is Allele, f'Expected parse("B*07:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_145():
    result = parse("B*07:145")
    assert result.__class__ is Allele, f'Expected parse("B*07:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_146():
    result = parse("B*07:146")
    assert result.__class__ is Allele, f'Expected parse("B*07:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_147():
    result = parse("B*07:147")
    assert result.__class__ is Allele, f'Expected parse("B*07:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_148():
    result = parse("B*07:148")
    assert result.__class__ is Allele, f'Expected parse("B*07:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_149():
    result = parse("B*07:149")
    assert result.__class__ is Allele, f'Expected parse("B*07:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_14_01():
    result = parse("B*07:14:01")
    assert result.__class__ is Allele, f'Expected parse("B*07:14:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:14:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_14_02():
    result = parse("B*07:14:02")
    assert result.__class__ is Allele, f'Expected parse("B*07:14:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:14:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_15():
    result = parse("B*07:15")
    assert result.__class__ is Allele, f'Expected parse("B*07:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_150():
    result = parse("B*07:150")
    assert result.__class__ is Allele, f'Expected parse("B*07:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_151_01():
    result = parse("B*07:151:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:151:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:151:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_151_02():
    result = parse("B*07:151:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:151:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:151:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_152():
    result = parse("B*07:152")
    assert result.__class__ is Allele, f'Expected parse("B*07:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_153():
    result = parse("B*07:153")
    assert result.__class__ is Allele, f'Expected parse("B*07:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_154():
    result = parse("B*07:154")
    assert result.__class__ is Allele, f'Expected parse("B*07:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_155():
    result = parse("B*07:155")
    assert result.__class__ is Allele, f'Expected parse("B*07:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_156():
    result = parse("B*07:156")
    assert result.__class__ is Allele, f'Expected parse("B*07:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_157():
    result = parse("B*07:157")
    assert result.__class__ is Allele, f'Expected parse("B*07:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_158():
    result = parse("B*07:158")
    assert result.__class__ is Allele, f'Expected parse("B*07:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_159():
    result = parse("B*07:159")
    assert result.__class__ is Allele, f'Expected parse("B*07:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_16():
    result = parse("B*07:16")
    assert result.__class__ is Allele, f'Expected parse("B*07:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_160():
    result = parse("B*07:160")
    assert result.__class__ is Allele, f'Expected parse("B*07:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_161N():
    result = parse("B*07:161N")
    assert result.__class__ is Allele, f'Expected parse("B*07:161N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:161N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_162():
    result = parse("B*07:162")
    assert result.__class__ is Allele, f'Expected parse("B*07:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_163():
    result = parse("B*07:163")
    assert result.__class__ is Allele, f'Expected parse("B*07:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_164():
    result = parse("B*07:164")
    assert result.__class__ is Allele, f'Expected parse("B*07:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_165():
    result = parse("B*07:165")
    assert result.__class__ is Allele, f'Expected parse("B*07:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_166():
    result = parse("B*07:166")
    assert result.__class__ is Allele, f'Expected parse("B*07:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_167N():
    result = parse("B*07:167N")
    assert result.__class__ is Allele, f'Expected parse("B*07:167N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:167N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_168():
    result = parse("B*07:168")
    assert result.__class__ is Allele, f'Expected parse("B*07:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_169():
    result = parse("B*07:169")
    assert result.__class__ is Allele, f'Expected parse("B*07:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_17():
    result = parse("B*07:17")
    assert result.__class__ is Allele, f'Expected parse("B*07:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_170():
    result = parse("B*07:170")
    assert result.__class__ is Allele, f'Expected parse("B*07:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_171():
    result = parse("B*07:171")
    assert result.__class__ is Allele, f'Expected parse("B*07:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_172():
    result = parse("B*07:172")
    assert result.__class__ is Allele, f'Expected parse("B*07:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_173():
    result = parse("B*07:173")
    assert result.__class__ is Allele, f'Expected parse("B*07:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_174():
    result = parse("B*07:174")
    assert result.__class__ is Allele, f'Expected parse("B*07:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_175():
    result = parse("B*07:175")
    assert result.__class__ is Allele, f'Expected parse("B*07:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_176():
    result = parse("B*07:176")
    assert result.__class__ is Allele, f'Expected parse("B*07:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_177():
    result = parse("B*07:177")
    assert result.__class__ is Allele, f'Expected parse("B*07:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_178():
    result = parse("B*07:178")
    assert result.__class__ is Allele, f'Expected parse("B*07:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_179():
    result = parse("B*07:179")
    assert result.__class__ is Allele, f'Expected parse("B*07:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_180():
    result = parse("B*07:180")
    assert result.__class__ is Allele, f'Expected parse("B*07:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_181N():
    result = parse("B*07:181N")
    assert result.__class__ is Allele, f'Expected parse("B*07:181N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:181N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_182N():
    result = parse("B*07:182N")
    assert result.__class__ is Allele, f'Expected parse("B*07:182N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:182N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_183():
    result = parse("B*07:183")
    assert result.__class__ is Allele, f'Expected parse("B*07:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_184():
    result = parse("B*07:184")
    assert result.__class__ is Allele, f'Expected parse("B*07:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_185():
    result = parse("B*07:185")
    assert result.__class__ is Allele, f'Expected parse("B*07:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_186():
    result = parse("B*07:186")
    assert result.__class__ is Allele, f'Expected parse("B*07:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_187():
    result = parse("B*07:187")
    assert result.__class__ is Allele, f'Expected parse("B*07:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_188():
    result = parse("B*07:188")
    assert result.__class__ is Allele, f'Expected parse("B*07:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_189():
    result = parse("B*07:189")
    assert result.__class__ is Allele, f'Expected parse("B*07:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_18_01():
    result = parse("B*07:18:01")
    assert result.__class__ is Allele, f'Expected parse("B*07:18:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:18:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_18_02():
    result = parse("B*07:18:02")
    assert result.__class__ is Allele, f'Expected parse("B*07:18:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:18:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_19():
    result = parse("B*07:19")
    assert result.__class__ is Allele, f'Expected parse("B*07:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_190():
    result = parse("B*07:190")
    assert result.__class__ is Allele, f'Expected parse("B*07:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_191():
    result = parse("B*07:191")
    assert result.__class__ is Allele, f'Expected parse("B*07:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_192():
    result = parse("B*07:192")
    assert result.__class__ is Allele, f'Expected parse("B*07:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_193():
    result = parse("B*07:193")
    assert result.__class__ is Allele, f'Expected parse("B*07:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_194():
    result = parse("B*07:194")
    assert result.__class__ is Allele, f'Expected parse("B*07:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_195():
    result = parse("B*07:195")
    assert result.__class__ is Allele, f'Expected parse("B*07:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_196():
    result = parse("B*07:196")
    assert result.__class__ is Allele, f'Expected parse("B*07:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_197():
    result = parse("B*07:197")
    assert result.__class__ is Allele, f'Expected parse("B*07:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_198():
    result = parse("B*07:198")
    assert result.__class__ is Allele, f'Expected parse("B*07:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_199():
    result = parse("B*07:199")
    assert result.__class__ is Allele, f'Expected parse("B*07:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_20():
    result = parse("B*07:20")
    assert result.__class__ is Allele, f'Expected parse("B*07:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_200():
    result = parse("B*07:200")
    assert result.__class__ is Allele, f'Expected parse("B*07:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_201N():
    result = parse("B*07:201N")
    assert result.__class__ is Allele, f'Expected parse("B*07:201N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:201N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_202():
    result = parse("B*07:202")
    assert result.__class__ is Allele, f'Expected parse("B*07:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_203():
    result = parse("B*07:203")
    assert result.__class__ is Allele, f'Expected parse("B*07:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_204():
    result = parse("B*07:204")
    assert result.__class__ is Allele, f'Expected parse("B*07:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_205():
    result = parse("B*07:205")
    assert result.__class__ is Allele, f'Expected parse("B*07:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_206():
    result = parse("B*07:206")
    assert result.__class__ is Allele, f'Expected parse("B*07:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_207():
    result = parse("B*07:207")
    assert result.__class__ is Allele, f'Expected parse("B*07:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_208():
    result = parse("B*07:208")
    assert result.__class__ is Allele, f'Expected parse("B*07:208") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_209():
    result = parse("B*07:209")
    assert result.__class__ is Allele, f'Expected parse("B*07:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_21():
    result = parse("B*07:21")
    assert result.__class__ is Allele, f'Expected parse("B*07:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_210():
    result = parse("B*07:210")
    assert result.__class__ is Allele, f'Expected parse("B*07:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_211():
    result = parse("B*07:211")
    assert result.__class__ is Allele, f'Expected parse("B*07:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_212():
    result = parse("B*07:212")
    assert result.__class__ is Allele, f'Expected parse("B*07:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_213():
    result = parse("B*07:213")
    assert result.__class__ is Allele, f'Expected parse("B*07:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_214():
    result = parse("B*07:214")
    assert result.__class__ is Allele, f'Expected parse("B*07:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_215():
    result = parse("B*07:215")
    assert result.__class__ is Allele, f'Expected parse("B*07:215") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_216():
    result = parse("B*07:216")
    assert result.__class__ is Allele, f'Expected parse("B*07:216") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_217():
    result = parse("B*07:217")
    assert result.__class__ is Allele, f'Expected parse("B*07:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_218():
    result = parse("B*07:218")
    assert result.__class__ is Allele, f'Expected parse("B*07:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_219():
    result = parse("B*07:219")
    assert result.__class__ is Allele, f'Expected parse("B*07:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_220():
    result = parse("B*07:220")
    assert result.__class__ is Allele, f'Expected parse("B*07:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_221():
    result = parse("B*07:221")
    assert result.__class__ is Allele, f'Expected parse("B*07:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_222():
    result = parse("B*07:222")
    assert result.__class__ is Allele, f'Expected parse("B*07:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_223():
    result = parse("B*07:223")
    assert result.__class__ is Allele, f'Expected parse("B*07:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_224():
    result = parse("B*07:224")
    assert result.__class__ is Allele, f'Expected parse("B*07:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_225():
    result = parse("B*07:225")
    assert result.__class__ is Allele, f'Expected parse("B*07:225") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_226():
    result = parse("B*07:226")
    assert result.__class__ is Allele, f'Expected parse("B*07:226") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_227():
    result = parse("B*07:227")
    assert result.__class__ is Allele, f'Expected parse("B*07:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_228_01():
    result = parse("B*07:228:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:228:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:228:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_228_02():
    result = parse("B*07:228:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:228:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:228:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_229_01():
    result = parse("B*07:229:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:229:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:229:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_229_02():
    result = parse("B*07:229:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:229:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:229:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_22_01():
    result = parse("B*07:22:01")
    assert result.__class__ is Allele, f'Expected parse("B*07:22:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:22:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_22_02():
    result = parse("B*07:22:02")
    assert result.__class__ is Allele, f'Expected parse("B*07:22:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:22:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_23():
    result = parse("B*07:23")
    assert result.__class__ is Allele, f'Expected parse("B*07:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_230():
    result = parse("B*07:230")
    assert result.__class__ is Allele, f'Expected parse("B*07:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_231N():
    result = parse("B*07:231N")
    assert result.__class__ is Allele, f'Expected parse("B*07:231N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:231N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_232():
    result = parse("B*07:232")
    assert result.__class__ is Allele, f'Expected parse("B*07:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_233():
    result = parse("B*07:233")
    assert result.__class__ is Allele, f'Expected parse("B*07:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_234():
    result = parse("B*07:234")
    assert result.__class__ is Allele, f'Expected parse("B*07:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_235():
    result = parse("B*07:235")
    assert result.__class__ is Allele, f'Expected parse("B*07:235") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_236():
    result = parse("B*07:236")
    assert result.__class__ is Allele, f'Expected parse("B*07:236") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_237():
    result = parse("B*07:237")
    assert result.__class__ is Allele, f'Expected parse("B*07:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_238():
    result = parse("B*07:238")
    assert result.__class__ is Allele, f'Expected parse("B*07:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_239():
    result = parse("B*07:239")
    assert result.__class__ is Allele, f'Expected parse("B*07:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_24():
    result = parse("B*07:24")
    assert result.__class__ is Allele, f'Expected parse("B*07:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_240():
    result = parse("B*07:240")
    assert result.__class__ is Allele, f'Expected parse("B*07:240") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_241():
    result = parse("B*07:241")
    assert result.__class__ is Allele, f'Expected parse("B*07:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_242():
    result = parse("B*07:242")
    assert result.__class__ is Allele, f'Expected parse("B*07:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_243():
    result = parse("B*07:243")
    assert result.__class__ is Allele, f'Expected parse("B*07:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_244():
    result = parse("B*07:244")
    assert result.__class__ is Allele, f'Expected parse("B*07:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_245():
    result = parse("B*07:245")
    assert result.__class__ is Allele, f'Expected parse("B*07:245") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_246():
    result = parse("B*07:246")
    assert result.__class__ is Allele, f'Expected parse("B*07:246") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_247():
    result = parse("B*07:247")
    assert result.__class__ is Allele, f'Expected parse("B*07:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_248():
    result = parse("B*07:248")
    assert result.__class__ is Allele, f'Expected parse("B*07:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_249():
    result = parse("B*07:249")
    assert result.__class__ is Allele, f'Expected parse("B*07:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_25():
    result = parse("B*07:25")
    assert result.__class__ is Allele, f'Expected parse("B*07:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_250():
    result = parse("B*07:250")
    assert result.__class__ is Allele, f'Expected parse("B*07:250") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_251N():
    result = parse("B*07:251N")
    assert result.__class__ is Allele, f'Expected parse("B*07:251N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:251N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_252():
    result = parse("B*07:252")
    assert result.__class__ is Allele, f'Expected parse("B*07:252") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_253():
    result = parse("B*07:253")
    assert result.__class__ is Allele, f'Expected parse("B*07:253") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_254():
    result = parse("B*07:254")
    assert result.__class__ is Allele, f'Expected parse("B*07:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_255():
    result = parse("B*07:255")
    assert result.__class__ is Allele, f'Expected parse("B*07:255") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_256():
    result = parse("B*07:256")
    assert result.__class__ is Allele, f'Expected parse("B*07:256") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_257():
    result = parse("B*07:257")
    assert result.__class__ is Allele, f'Expected parse("B*07:257") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_258():
    result = parse("B*07:258")
    assert result.__class__ is Allele, f'Expected parse("B*07:258") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_259():
    result = parse("B*07:259")
    assert result.__class__ is Allele, f'Expected parse("B*07:259") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_26():
    result = parse("B*07:26")
    assert result.__class__ is Allele, f'Expected parse("B*07:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_260():
    result = parse("B*07:260")
    assert result.__class__ is Allele, f'Expected parse("B*07:260") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_261():
    result = parse("B*07:261")
    assert result.__class__ is Allele, f'Expected parse("B*07:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_262():
    result = parse("B*07:262")
    assert result.__class__ is Allele, f'Expected parse("B*07:262") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_263():
    result = parse("B*07:263")
    assert result.__class__ is Allele, f'Expected parse("B*07:263") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_264():
    result = parse("B*07:264")
    assert result.__class__ is Allele, f'Expected parse("B*07:264") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_265():
    result = parse("B*07:265")
    assert result.__class__ is Allele, f'Expected parse("B*07:265") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_266():
    result = parse("B*07:266")
    assert result.__class__ is Allele, f'Expected parse("B*07:266") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_267():
    result = parse("B*07:267")
    assert result.__class__ is Allele, f'Expected parse("B*07:267") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_268():
    result = parse("B*07:268")
    assert result.__class__ is Allele, f'Expected parse("B*07:268") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_269():
    result = parse("B*07:269")
    assert result.__class__ is Allele, f'Expected parse("B*07:269") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_27():
    result = parse("B*07:27")
    assert result.__class__ is Allele, f'Expected parse("B*07:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_270():
    result = parse("B*07:270")
    assert result.__class__ is Allele, f'Expected parse("B*07:270") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_271():
    result = parse("B*07:271")
    assert result.__class__ is Allele, f'Expected parse("B*07:271") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_272N():
    result = parse("B*07:272N")
    assert result.__class__ is Allele, f'Expected parse("B*07:272N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:272N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_273():
    result = parse("B*07:273")
    assert result.__class__ is Allele, f'Expected parse("B*07:273") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_274():
    result = parse("B*07:274")
    assert result.__class__ is Allele, f'Expected parse("B*07:274") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_275():
    result = parse("B*07:275")
    assert result.__class__ is Allele, f'Expected parse("B*07:275") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_276_01():
    result = parse("B*07:276:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:276:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:276:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_276_02():
    result = parse("B*07:276:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:276:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:276:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_277():
    result = parse("B*07:277")
    assert result.__class__ is Allele, f'Expected parse("B*07:277") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_278():
    result = parse("B*07:278")
    assert result.__class__ is Allele, f'Expected parse("B*07:278") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_279():
    result = parse("B*07:279")
    assert result.__class__ is Allele, f'Expected parse("B*07:279") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_28():
    result = parse("B*07:28")
    assert result.__class__ is Allele, f'Expected parse("B*07:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_280():
    result = parse("B*07:280")
    assert result.__class__ is Allele, f'Expected parse("B*07:280") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_281():
    result = parse("B*07:281")
    assert result.__class__ is Allele, f'Expected parse("B*07:281") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_282():
    result = parse("B*07:282")
    assert result.__class__ is Allele, f'Expected parse("B*07:282") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_283():
    result = parse("B*07:283")
    assert result.__class__ is Allele, f'Expected parse("B*07:283") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_284():
    result = parse("B*07:284")
    assert result.__class__ is Allele, f'Expected parse("B*07:284") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_285N():
    result = parse("B*07:285N")
    assert result.__class__ is Allele, f'Expected parse("B*07:285N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:285N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_286():
    result = parse("B*07:286")
    assert result.__class__ is Allele, f'Expected parse("B*07:286") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_287():
    result = parse("B*07:287")
    assert result.__class__ is Allele, f'Expected parse("B*07:287") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:287") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_288():
    result = parse("B*07:288")
    assert result.__class__ is Allele, f'Expected parse("B*07:288") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_289():
    result = parse("B*07:289")
    assert result.__class__ is Allele, f'Expected parse("B*07:289") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_29():
    result = parse("B*07:29")
    assert result.__class__ is Allele, f'Expected parse("B*07:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_290():
    result = parse("B*07:290")
    assert result.__class__ is Allele, f'Expected parse("B*07:290") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_291():
    result = parse("B*07:291")
    assert result.__class__ is Allele, f'Expected parse("B*07:291") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_292():
    result = parse("B*07:292")
    assert result.__class__ is Allele, f'Expected parse("B*07:292") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_293():
    result = parse("B*07:293")
    assert result.__class__ is Allele, f'Expected parse("B*07:293") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_294():
    result = parse("B*07:294")
    assert result.__class__ is Allele, f'Expected parse("B*07:294") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_295():
    result = parse("B*07:295")
    assert result.__class__ is Allele, f'Expected parse("B*07:295") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_296():
    result = parse("B*07:296")
    assert result.__class__ is Allele, f'Expected parse("B*07:296") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_297():
    result = parse("B*07:297")
    assert result.__class__ is Allele, f'Expected parse("B*07:297") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_298():
    result = parse("B*07:298")
    assert result.__class__ is Allele, f'Expected parse("B*07:298") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_299():
    result = parse("B*07:299")
    assert result.__class__ is Allele, f'Expected parse("B*07:299") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_30():
    result = parse("B*07:30")
    assert result.__class__ is Allele, f'Expected parse("B*07:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_300():
    result = parse("B*07:300")
    assert result.__class__ is Allele, f'Expected parse("B*07:300") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_301():
    result = parse("B*07:301")
    assert result.__class__ is Allele, f'Expected parse("B*07:301") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_302():
    result = parse("B*07:302")
    assert result.__class__ is Allele, f'Expected parse("B*07:302") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_303_01():
    result = parse("B*07:303:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:303:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:303:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_303_02():
    result = parse("B*07:303:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:303:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:303:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_304():
    result = parse("B*07:304")
    assert result.__class__ is Allele, f'Expected parse("B*07:304") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:304") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_305():
    result = parse("B*07:305")
    assert result.__class__ is Allele, f'Expected parse("B*07:305") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_306():
    result = parse("B*07:306")
    assert result.__class__ is Allele, f'Expected parse("B*07:306") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:306") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_307():
    result = parse("B*07:307")
    assert result.__class__ is Allele, f'Expected parse("B*07:307") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_308():
    result = parse("B*07:308")
    assert result.__class__ is Allele, f'Expected parse("B*07:308") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:308") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_309():
    result = parse("B*07:309")
    assert result.__class__ is Allele, f'Expected parse("B*07:309") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:309") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_31():
    result = parse("B*07:31")
    assert result.__class__ is Allele, f'Expected parse("B*07:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_310():
    result = parse("B*07:310")
    assert result.__class__ is Allele, f'Expected parse("B*07:310") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:310") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_311():
    result = parse("B*07:311")
    assert result.__class__ is Allele, f'Expected parse("B*07:311") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:311") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_312():
    result = parse("B*07:312")
    assert result.__class__ is Allele, f'Expected parse("B*07:312") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:312") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_313():
    result = parse("B*07:313")
    assert result.__class__ is Allele, f'Expected parse("B*07:313") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:313") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_314():
    result = parse("B*07:314")
    assert result.__class__ is Allele, f'Expected parse("B*07:314") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:314") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_315N():
    result = parse("B*07:315N")
    assert result.__class__ is Allele, f'Expected parse("B*07:315N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:315N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_316N():
    result = parse("B*07:316N")
    assert result.__class__ is Allele, f'Expected parse("B*07:316N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:316N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_317():
    result = parse("B*07:317")
    assert result.__class__ is Allele, f'Expected parse("B*07:317") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:317") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_318N():
    result = parse("B*07:318N")
    assert result.__class__ is Allele, f'Expected parse("B*07:318N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:318N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_319():
    result = parse("B*07:319")
    assert result.__class__ is Allele, f'Expected parse("B*07:319") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_32():
    result = parse("B*07:32")
    assert result.__class__ is Allele, f'Expected parse("B*07:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_320():
    result = parse("B*07:320")
    assert result.__class__ is Allele, f'Expected parse("B*07:320") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:320") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_321():
    result = parse("B*07:321")
    assert result.__class__ is Allele, f'Expected parse("B*07:321") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:321") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_322():
    result = parse("B*07:322")
    assert result.__class__ is Allele, f'Expected parse("B*07:322") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:322") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_323():
    result = parse("B*07:323")
    assert result.__class__ is Allele, f'Expected parse("B*07:323") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:323") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_324():
    result = parse("B*07:324")
    assert result.__class__ is Allele, f'Expected parse("B*07:324") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:324") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_325N():
    result = parse("B*07:325N")
    assert result.__class__ is Allele, f'Expected parse("B*07:325N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:325N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_326():
    result = parse("B*07:326")
    assert result.__class__ is Allele, f'Expected parse("B*07:326") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:326") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_327():
    result = parse("B*07:327")
    assert result.__class__ is Allele, f'Expected parse("B*07:327") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:327") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_328():
    result = parse("B*07:328")
    assert result.__class__ is Allele, f'Expected parse("B*07:328") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:328") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_329():
    result = parse("B*07:329")
    assert result.__class__ is Allele, f'Expected parse("B*07:329") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:329") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_330N():
    result = parse("B*07:330N")
    assert result.__class__ is Allele, f'Expected parse("B*07:330N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:330N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_331():
    result = parse("B*07:331")
    assert result.__class__ is Allele, f'Expected parse("B*07:331") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:331") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_332():
    result = parse("B*07:332")
    assert result.__class__ is Allele, f'Expected parse("B*07:332") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:332") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_333():
    result = parse("B*07:333")
    assert result.__class__ is Allele, f'Expected parse("B*07:333") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:333") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_334():
    result = parse("B*07:334")
    assert result.__class__ is Allele, f'Expected parse("B*07:334") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:334") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_335():
    result = parse("B*07:335")
    assert result.__class__ is Allele, f'Expected parse("B*07:335") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:335") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_336():
    result = parse("B*07:336")
    assert result.__class__ is Allele, f'Expected parse("B*07:336") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:336") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_337():
    result = parse("B*07:337")
    assert result.__class__ is Allele, f'Expected parse("B*07:337") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:337") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_338():
    result = parse("B*07:338")
    assert result.__class__ is Allele, f'Expected parse("B*07:338") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:338") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_339():
    result = parse("B*07:339")
    assert result.__class__ is Allele, f'Expected parse("B*07:339") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:339") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_33_01():
    result = parse("B*07:33:01")
    assert result.__class__ is Allele, f'Expected parse("B*07:33:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:33:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_33_02():
    result = parse("B*07:33:02")
    assert result.__class__ is Allele, f'Expected parse("B*07:33:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:33:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_33_03():
    result = parse("B*07:33:03")
    assert result.__class__ is Allele, f'Expected parse("B*07:33:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:33:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_34():
    result = parse("B*07:34")
    assert result.__class__ is Allele, f'Expected parse("B*07:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_340():
    result = parse("B*07:340")
    assert result.__class__ is Allele, f'Expected parse("B*07:340") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:340") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_341():
    result = parse("B*07:341")
    assert result.__class__ is Allele, f'Expected parse("B*07:341") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:341") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_342():
    result = parse("B*07:342")
    assert result.__class__ is Allele, f'Expected parse("B*07:342") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:342") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_343N():
    result = parse("B*07:343N")
    assert result.__class__ is Allele, f'Expected parse("B*07:343N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:343N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_344():
    result = parse("B*07:344")
    assert result.__class__ is Allele, f'Expected parse("B*07:344") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:344") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_345():
    result = parse("B*07:345")
    assert result.__class__ is Allele, f'Expected parse("B*07:345") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:345") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_346():
    result = parse("B*07:346")
    assert result.__class__ is Allele, f'Expected parse("B*07:346") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:346") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_347():
    result = parse("B*07:347")
    assert result.__class__ is Allele, f'Expected parse("B*07:347") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:347") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_348():
    result = parse("B*07:348")
    assert result.__class__ is Allele, f'Expected parse("B*07:348") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:348") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_349():
    result = parse("B*07:349")
    assert result.__class__ is Allele, f'Expected parse("B*07:349") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:349") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_35():
    result = parse("B*07:35")
    assert result.__class__ is Allele, f'Expected parse("B*07:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_350():
    result = parse("B*07:350")
    assert result.__class__ is Allele, f'Expected parse("B*07:350") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:350") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_351N():
    result = parse("B*07:351N")
    assert result.__class__ is Allele, f'Expected parse("B*07:351N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:351N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_352():
    result = parse("B*07:352")
    assert result.__class__ is Allele, f'Expected parse("B*07:352") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:352") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_353():
    result = parse("B*07:353")
    assert result.__class__ is Allele, f'Expected parse("B*07:353") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:353") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_354():
    result = parse("B*07:354")
    assert result.__class__ is Allele, f'Expected parse("B*07:354") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:354") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_355():
    result = parse("B*07:355")
    assert result.__class__ is Allele, f'Expected parse("B*07:355") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:355") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_356():
    result = parse("B*07:356")
    assert result.__class__ is Allele, f'Expected parse("B*07:356") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:356") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_357():
    result = parse("B*07:357")
    assert result.__class__ is Allele, f'Expected parse("B*07:357") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:357") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_358():
    result = parse("B*07:358")
    assert result.__class__ is Allele, f'Expected parse("B*07:358") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:358") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_359():
    result = parse("B*07:359")
    assert result.__class__ is Allele, f'Expected parse("B*07:359") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:359") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_36():
    result = parse("B*07:36")
    assert result.__class__ is Allele, f'Expected parse("B*07:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_360Q():
    result = parse("B*07:360Q")
    assert result.__class__ is Allele, f'Expected parse("B*07:360Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:360Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_361():
    result = parse("B*07:361")
    assert result.__class__ is Allele, f'Expected parse("B*07:361") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:361") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_362():
    result = parse("B*07:362")
    assert result.__class__ is Allele, f'Expected parse("B*07:362") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:362") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_363():
    result = parse("B*07:363")
    assert result.__class__ is Allele, f'Expected parse("B*07:363") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:363") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_364():
    result = parse("B*07:364")
    assert result.__class__ is Allele, f'Expected parse("B*07:364") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:364") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_365():
    result = parse("B*07:365")
    assert result.__class__ is Allele, f'Expected parse("B*07:365") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:365") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_366():
    result = parse("B*07:366")
    assert result.__class__ is Allele, f'Expected parse("B*07:366") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:366") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_367():
    result = parse("B*07:367")
    assert result.__class__ is Allele, f'Expected parse("B*07:367") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:367") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_368():
    result = parse("B*07:368")
    assert result.__class__ is Allele, f'Expected parse("B*07:368") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:368") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_369():
    result = parse("B*07:369")
    assert result.__class__ is Allele, f'Expected parse("B*07:369") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:369") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_370():
    result = parse("B*07:370")
    assert result.__class__ is Allele, f'Expected parse("B*07:370") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:370") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_371():
    result = parse("B*07:371")
    assert result.__class__ is Allele, f'Expected parse("B*07:371") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:371") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_372():
    result = parse("B*07:372")
    assert result.__class__ is Allele, f'Expected parse("B*07:372") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:372") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_373N():
    result = parse("B*07:373N")
    assert result.__class__ is Allele, f'Expected parse("B*07:373N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:373N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_374N():
    result = parse("B*07:374N")
    assert result.__class__ is Allele, f'Expected parse("B*07:374N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:374N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_375():
    result = parse("B*07:375")
    assert result.__class__ is Allele, f'Expected parse("B*07:375") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:375") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_376():
    result = parse("B*07:376")
    assert result.__class__ is Allele, f'Expected parse("B*07:376") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:376") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_377():
    result = parse("B*07:377")
    assert result.__class__ is Allele, f'Expected parse("B*07:377") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:377") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_378():
    result = parse("B*07:378")
    assert result.__class__ is Allele, f'Expected parse("B*07:378") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:378") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_379():
    result = parse("B*07:379")
    assert result.__class__ is Allele, f'Expected parse("B*07:379") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:379") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_37_01():
    result = parse("B*07:37:01")
    assert result.__class__ is Allele, f'Expected parse("B*07:37:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:37:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_37_02():
    result = parse("B*07:37:02")
    assert result.__class__ is Allele, f'Expected parse("B*07:37:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:37:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_38():
    result = parse("B*07:38")
    assert result.__class__ is Allele, f'Expected parse("B*07:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_380():
    result = parse("B*07:380")
    assert result.__class__ is Allele, f'Expected parse("B*07:380") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:380") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_381():
    result = parse("B*07:381")
    assert result.__class__ is Allele, f'Expected parse("B*07:381") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:381") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_382():
    result = parse("B*07:382")
    assert result.__class__ is Allele, f'Expected parse("B*07:382") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:382") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_383():
    result = parse("B*07:383")
    assert result.__class__ is Allele, f'Expected parse("B*07:383") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:383") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_384():
    result = parse("B*07:384")
    assert result.__class__ is Allele, f'Expected parse("B*07:384") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:384") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_385():
    result = parse("B*07:385")
    assert result.__class__ is Allele, f'Expected parse("B*07:385") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:385") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_386N():
    result = parse("B*07:386N")
    assert result.__class__ is Allele, f'Expected parse("B*07:386N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:386N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_387():
    result = parse("B*07:387")
    assert result.__class__ is Allele, f'Expected parse("B*07:387") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:387") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_388():
    result = parse("B*07:388")
    assert result.__class__ is Allele, f'Expected parse("B*07:388") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:388") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_389():
    result = parse("B*07:389")
    assert result.__class__ is Allele, f'Expected parse("B*07:389") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:389") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_39():
    result = parse("B*07:39")
    assert result.__class__ is Allele, f'Expected parse("B*07:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_390():
    result = parse("B*07:390")
    assert result.__class__ is Allele, f'Expected parse("B*07:390") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:390") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_391():
    result = parse("B*07:391")
    assert result.__class__ is Allele, f'Expected parse("B*07:391") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:391") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_392():
    result = parse("B*07:392")
    assert result.__class__ is Allele, f'Expected parse("B*07:392") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:392") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_393():
    result = parse("B*07:393")
    assert result.__class__ is Allele, f'Expected parse("B*07:393") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:393") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_394():
    result = parse("B*07:394")
    assert result.__class__ is Allele, f'Expected parse("B*07:394") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:394") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_395():
    result = parse("B*07:395")
    assert result.__class__ is Allele, f'Expected parse("B*07:395") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:395") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_396():
    result = parse("B*07:396")
    assert result.__class__ is Allele, f'Expected parse("B*07:396") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:396") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_397():
    result = parse("B*07:397")
    assert result.__class__ is Allele, f'Expected parse("B*07:397") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:397") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_398():
    result = parse("B*07:398")
    assert result.__class__ is Allele, f'Expected parse("B*07:398") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:398") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_399():
    result = parse("B*07:399")
    assert result.__class__ is Allele, f'Expected parse("B*07:399") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:399") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_40():
    result = parse("B*07:40")
    assert result.__class__ is Allele, f'Expected parse("B*07:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_400():
    result = parse("B*07:400")
    assert result.__class__ is Allele, f'Expected parse("B*07:400") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:400") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_401():
    result = parse("B*07:401")
    assert result.__class__ is Allele, f'Expected parse("B*07:401") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:401") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_402():
    result = parse("B*07:402")
    assert result.__class__ is Allele, f'Expected parse("B*07:402") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:402") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_403():
    result = parse("B*07:403")
    assert result.__class__ is Allele, f'Expected parse("B*07:403") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:403") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_404():
    result = parse("B*07:404")
    assert result.__class__ is Allele, f'Expected parse("B*07:404") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:404") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_405():
    result = parse("B*07:405")
    assert result.__class__ is Allele, f'Expected parse("B*07:405") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:405") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_406():
    result = parse("B*07:406")
    assert result.__class__ is Allele, f'Expected parse("B*07:406") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:406") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_407():
    result = parse("B*07:407")
    assert result.__class__ is Allele, f'Expected parse("B*07:407") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:407") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_41():
    result = parse("B*07:41")
    assert result.__class__ is Allele, f'Expected parse("B*07:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_42():
    result = parse("B*07:42")
    assert result.__class__ is Allele, f'Expected parse("B*07:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_43():
    result = parse("B*07:43")
    assert result.__class__ is Allele, f'Expected parse("B*07:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_44N():
    result = parse("B*07:44N")
    assert result.__class__ is Allele, f'Expected parse("B*07:44N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:44N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_45():
    result = parse("B*07:45")
    assert result.__class__ is Allele, f'Expected parse("B*07:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_46():
    result = parse("B*07:46")
    assert result.__class__ is Allele, f'Expected parse("B*07:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_47():
    result = parse("B*07:47")
    assert result.__class__ is Allele, f'Expected parse("B*07:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_48():
    result = parse("B*07:48")
    assert result.__class__ is Allele, f'Expected parse("B*07:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_49N():
    result = parse("B*07:49N")
    assert result.__class__ is Allele, f'Expected parse("B*07:49N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:49N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_50():
    result = parse("B*07:50")
    assert result.__class__ is Allele, f'Expected parse("B*07:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_51():
    result = parse("B*07:51")
    assert result.__class__ is Allele, f'Expected parse("B*07:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_52():
    result = parse("B*07:52")
    assert result.__class__ is Allele, f'Expected parse("B*07:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_53():
    result = parse("B*07:53")
    assert result.__class__ is Allele, f'Expected parse("B*07:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_54():
    result = parse("B*07:54")
    assert result.__class__ is Allele, f'Expected parse("B*07:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_55():
    result = parse("B*07:55")
    assert result.__class__ is Allele, f'Expected parse("B*07:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_56_01():
    result = parse("B*07:56:01")
    assert result.__class__ is Allele, f'Expected parse("B*07:56:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:56:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_56_02():
    result = parse("B*07:56:02")
    assert result.__class__ is Allele, f'Expected parse("B*07:56:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:56:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_57():
    result = parse("B*07:57")
    assert result.__class__ is Allele, f'Expected parse("B*07:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_58():
    result = parse("B*07:58")
    assert result.__class__ is Allele, f'Expected parse("B*07:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_59():
    result = parse("B*07:59")
    assert result.__class__ is Allele, f'Expected parse("B*07:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_60():
    result = parse("B*07:60")
    assert result.__class__ is Allele, f'Expected parse("B*07:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_61():
    result = parse("B*07:61")
    assert result.__class__ is Allele, f'Expected parse("B*07:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_62():
    result = parse("B*07:62")
    assert result.__class__ is Allele, f'Expected parse("B*07:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_63():
    result = parse("B*07:63")
    assert result.__class__ is Allele, f'Expected parse("B*07:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_64():
    result = parse("B*07:64")
    assert result.__class__ is Allele, f'Expected parse("B*07:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_65():
    result = parse("B*07:65")
    assert result.__class__ is Allele, f'Expected parse("B*07:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_66():
    result = parse("B*07:66")
    assert result.__class__ is Allele, f'Expected parse("B*07:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_67N():
    result = parse("B*07:67N")
    assert result.__class__ is Allele, f'Expected parse("B*07:67N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:67N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_68_01():
    result = parse("B*07:68:01")
    assert result.__class__ is Allele, f'Expected parse("B*07:68:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:68:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_68_02():
    result = parse("B*07:68:02")
    assert result.__class__ is Allele, f'Expected parse("B*07:68:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:68:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_68_03():
    result = parse("B*07:68:03")
    assert result.__class__ is Allele, f'Expected parse("B*07:68:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:68:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_69():
    result = parse("B*07:69")
    assert result.__class__ is Allele, f'Expected parse("B*07:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_70():
    result = parse("B*07:70")
    assert result.__class__ is Allele, f'Expected parse("B*07:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_71():
    result = parse("B*07:71")
    assert result.__class__ is Allele, f'Expected parse("B*07:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_72():
    result = parse("B*07:72")
    assert result.__class__ is Allele, f'Expected parse("B*07:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_73():
    result = parse("B*07:73")
    assert result.__class__ is Allele, f'Expected parse("B*07:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_74():
    result = parse("B*07:74")
    assert result.__class__ is Allele, f'Expected parse("B*07:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_75_01_01():
    result = parse("B*07:75:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:75:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:75:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_75_01_02():
    result = parse("B*07:75:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*07:75:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*07:75:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_76():
    result = parse("B*07:76")
    assert result.__class__ is Allele, f'Expected parse("B*07:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_77():
    result = parse("B*07:77")
    assert result.__class__ is Allele, f'Expected parse("B*07:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_78():
    result = parse("B*07:78")
    assert result.__class__ is Allele, f'Expected parse("B*07:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_79():
    result = parse("B*07:79")
    assert result.__class__ is Allele, f'Expected parse("B*07:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_80():
    result = parse("B*07:80")
    assert result.__class__ is Allele, f'Expected parse("B*07:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_81():
    result = parse("B*07:81")
    assert result.__class__ is Allele, f'Expected parse("B*07:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_82():
    result = parse("B*07:82")
    assert result.__class__ is Allele, f'Expected parse("B*07:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_83():
    result = parse("B*07:83")
    assert result.__class__ is Allele, f'Expected parse("B*07:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_84():
    result = parse("B*07:84")
    assert result.__class__ is Allele, f'Expected parse("B*07:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_85_01():
    result = parse("B*07:85:01")
    assert result.__class__ is Allele, f'Expected parse("B*07:85:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:85:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_85_02():
    result = parse("B*07:85:02")
    assert result.__class__ is Allele, f'Expected parse("B*07:85:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:85:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_86():
    result = parse("B*07:86")
    assert result.__class__ is Allele, f'Expected parse("B*07:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_87():
    result = parse("B*07:87")
    assert result.__class__ is Allele, f'Expected parse("B*07:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_88():
    result = parse("B*07:88")
    assert result.__class__ is Allele, f'Expected parse("B*07:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_89():
    result = parse("B*07:89")
    assert result.__class__ is Allele, f'Expected parse("B*07:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_90():
    result = parse("B*07:90")
    assert result.__class__ is Allele, f'Expected parse("B*07:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_91():
    result = parse("B*07:91")
    assert result.__class__ is Allele, f'Expected parse("B*07:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_92():
    result = parse("B*07:92")
    assert result.__class__ is Allele, f'Expected parse("B*07:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_93():
    result = parse("B*07:93")
    assert result.__class__ is Allele, f'Expected parse("B*07:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_94():
    result = parse("B*07:94")
    assert result.__class__ is Allele, f'Expected parse("B*07:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_95():
    result = parse("B*07:95")
    assert result.__class__ is Allele, f'Expected parse("B*07:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_96_01():
    result = parse("B*07:96:01")
    assert result.__class__ is Allele, f'Expected parse("B*07:96:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:96:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_96_02():
    result = parse("B*07:96:02")
    assert result.__class__ is Allele, f'Expected parse("B*07:96:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*07:96:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_97():
    result = parse("B*07:97")
    assert result.__class__ is Allele, f'Expected parse("B*07:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_98():
    result = parse("B*07:98")
    assert result.__class__ is Allele, f'Expected parse("B*07:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_07_99():
    result = parse("B*07:99")
    assert result.__class__ is Allele, f'Expected parse("B*07:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*07:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_01():
    result = parse("B*08:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_02():
    result = parse("B*08:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_03():
    result = parse("B*08:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_04():
    result = parse("B*08:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_05():
    result = parse("B*08:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_06():
    result = parse("B*08:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_07():
    result = parse("B*08:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_08():
    result = parse("B*08:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_09():
    result = parse("B*08:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_10():
    result = parse("B*08:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_11():
    result = parse("B*08:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_12():
    result = parse("B*08:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_13():
    result = parse("B*08:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_14():
    result = parse("B*08:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_15():
    result = parse("B*08:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_16():
    result = parse("B*08:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_17():
    result = parse("B*08:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_18():
    result = parse("B*08:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_19():
    result = parse("B*08:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_20():
    result = parse("B*08:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_21():
    result = parse("B*08:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_22():
    result = parse("B*08:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_23():
    result = parse("B*08:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_24():
    result = parse("B*08:01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_25():
    result = parse("B*08:01:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_26():
    result = parse("B*08:01:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_27():
    result = parse("B*08:01:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_28():
    result = parse("B*08:01:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_29():
    result = parse("B*08:01:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_30():
    result = parse("B*08:01:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_31():
    result = parse("B*08:01:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_32():
    result = parse("B*08:01:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_33():
    result = parse("B*08:01:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_34():
    result = parse("B*08:01:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_35():
    result = parse("B*08:01:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_36():
    result = parse("B*08:01:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_37():
    result = parse("B*08:01:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_01_38():
    result = parse("B*08:01:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:01:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*08:01:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_02():
    result = parse("B*08:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_03():
    result = parse("B*08:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_04():
    result = parse("B*08:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_05():
    result = parse("B*08:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_06():
    result = parse("B*08:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_07():
    result = parse("B*08:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_08():
    result = parse("B*08:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_09():
    result = parse("B*08:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_10():
    result = parse("B*08:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_11():
    result = parse("B*08:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_12():
    result = parse("B*08:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_13():
    result = parse("B*08:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_14():
    result = parse("B*08:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_15():
    result = parse("B*08:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_16():
    result = parse("B*08:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_17():
    result = parse("B*08:01:17")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_18():
    result = parse("B*08:01:18")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_19():
    result = parse("B*08:01:19")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_20():
    result = parse("B*08:01:20")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_21():
    result = parse("B*08:01:21")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_22():
    result = parse("B*08:01:22")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_23():
    result = parse("B*08:01:23")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_24():
    result = parse("B*08:01:24")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_25():
    result = parse("B*08:01:25")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_26():
    result = parse("B*08:01:26")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_27():
    result = parse("B*08:01:27")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_28():
    result = parse("B*08:01:28")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_29():
    result = parse("B*08:01:29")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_30():
    result = parse("B*08:01:30")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_31():
    result = parse("B*08:01:31")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_32():
    result = parse("B*08:01:32")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_33():
    result = parse("B*08:01:33")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_34():
    result = parse("B*08:01:34")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_35():
    result = parse("B*08:01:35")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_36():
    result = parse("B*08:01:36")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_37():
    result = parse("B*08:01:37")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_38():
    result = parse("B*08:01:38")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_39():
    result = parse("B*08:01:39")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_40():
    result = parse("B*08:01:40")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_41():
    result = parse("B*08:01:41")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_42():
    result = parse("B*08:01:42")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_43():
    result = parse("B*08:01:43")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_44():
    result = parse("B*08:01:44")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_45():
    result = parse("B*08:01:45")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_46():
    result = parse("B*08:01:46")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_47():
    result = parse("B*08:01:47")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_48():
    result = parse("B*08:01:48")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_49():
    result = parse("B*08:01:49")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_50():
    result = parse("B*08:01:50")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_51():
    result = parse("B*08:01:51")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_52():
    result = parse("B*08:01:52")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_53():
    result = parse("B*08:01:53")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_54():
    result = parse("B*08:01:54")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_55():
    result = parse("B*08:01:55")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_01_56():
    result = parse("B*08:01:56")
    assert result.__class__ is Allele, f'Expected parse("B*08:01:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:01:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_02():
    result = parse("B*08:02")
    assert result.__class__ is Allele, f'Expected parse("B*08:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_03():
    result = parse("B*08:03")
    assert result.__class__ is Allele, f'Expected parse("B*08:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_04_01():
    result = parse("B*08:04:01")
    assert result.__class__ is Allele, f'Expected parse("B*08:04:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_04_02():
    result = parse("B*08:04:02")
    assert result.__class__ is Allele, f'Expected parse("B*08:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_05():
    result = parse("B*08:05")
    assert result.__class__ is Allele, f'Expected parse("B*08:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_07():
    result = parse("B*08:07")
    assert result.__class__ is Allele, f'Expected parse("B*08:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_08N():
    result = parse("B*08:08N")
    assert result.__class__ is Allele, f'Expected parse("B*08:08N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:08N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_09():
    result = parse("B*08:09")
    assert result.__class__ is Allele, f'Expected parse("B*08:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_10():
    result = parse("B*08:10")
    assert result.__class__ is Allele, f'Expected parse("B*08:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_100():
    result = parse("B*08:100")
    assert result.__class__ is Allele, f'Expected parse("B*08:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_101():
    result = parse("B*08:101")
    assert result.__class__ is Allele, f'Expected parse("B*08:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_102():
    result = parse("B*08:102")
    assert result.__class__ is Allele, f'Expected parse("B*08:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_103():
    result = parse("B*08:103")
    assert result.__class__ is Allele, f'Expected parse("B*08:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_104():
    result = parse("B*08:104")
    assert result.__class__ is Allele, f'Expected parse("B*08:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_105():
    result = parse("B*08:105")
    assert result.__class__ is Allele, f'Expected parse("B*08:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_106():
    result = parse("B*08:106")
    assert result.__class__ is Allele, f'Expected parse("B*08:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_107():
    result = parse("B*08:107")
    assert result.__class__ is Allele, f'Expected parse("B*08:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_108():
    result = parse("B*08:108")
    assert result.__class__ is Allele, f'Expected parse("B*08:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_109():
    result = parse("B*08:109")
    assert result.__class__ is Allele, f'Expected parse("B*08:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_11():
    result = parse("B*08:11")
    assert result.__class__ is Allele, f'Expected parse("B*08:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_110():
    result = parse("B*08:110")
    assert result.__class__ is Allele, f'Expected parse("B*08:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_111():
    result = parse("B*08:111")
    assert result.__class__ is Allele, f'Expected parse("B*08:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_112():
    result = parse("B*08:112")
    assert result.__class__ is Allele, f'Expected parse("B*08:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_113():
    result = parse("B*08:113")
    assert result.__class__ is Allele, f'Expected parse("B*08:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_114():
    result = parse("B*08:114")
    assert result.__class__ is Allele, f'Expected parse("B*08:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_115():
    result = parse("B*08:115")
    assert result.__class__ is Allele, f'Expected parse("B*08:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_116():
    result = parse("B*08:116")
    assert result.__class__ is Allele, f'Expected parse("B*08:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_117():
    result = parse("B*08:117")
    assert result.__class__ is Allele, f'Expected parse("B*08:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_118():
    result = parse("B*08:118")
    assert result.__class__ is Allele, f'Expected parse("B*08:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_119():
    result = parse("B*08:119")
    assert result.__class__ is Allele, f'Expected parse("B*08:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_120():
    result = parse("B*08:120")
    assert result.__class__ is Allele, f'Expected parse("B*08:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_121():
    result = parse("B*08:121")
    assert result.__class__ is Allele, f'Expected parse("B*08:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_122():
    result = parse("B*08:122")
    assert result.__class__ is Allele, f'Expected parse("B*08:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_123():
    result = parse("B*08:123")
    assert result.__class__ is Allele, f'Expected parse("B*08:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_124():
    result = parse("B*08:124")
    assert result.__class__ is Allele, f'Expected parse("B*08:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_125():
    result = parse("B*08:125")
    assert result.__class__ is Allele, f'Expected parse("B*08:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_126():
    result = parse("B*08:126")
    assert result.__class__ is Allele, f'Expected parse("B*08:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_127():
    result = parse("B*08:127")
    assert result.__class__ is Allele, f'Expected parse("B*08:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_128():
    result = parse("B*08:128")
    assert result.__class__ is Allele, f'Expected parse("B*08:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_129():
    result = parse("B*08:129")
    assert result.__class__ is Allele, f'Expected parse("B*08:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_12_01():
    result = parse("B*08:12:01")
    assert result.__class__ is Allele, f'Expected parse("B*08:12:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:12:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_12_02():
    result = parse("B*08:12:02")
    assert result.__class__ is Allele, f'Expected parse("B*08:12:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:12:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_12_03():
    result = parse("B*08:12:03")
    assert result.__class__ is Allele, f'Expected parse("B*08:12:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:12:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_13():
    result = parse("B*08:13")
    assert result.__class__ is Allele, f'Expected parse("B*08:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_130():
    result = parse("B*08:130")
    assert result.__class__ is Allele, f'Expected parse("B*08:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_131():
    result = parse("B*08:131")
    assert result.__class__ is Allele, f'Expected parse("B*08:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_132():
    result = parse("B*08:132")
    assert result.__class__ is Allele, f'Expected parse("B*08:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_133():
    result = parse("B*08:133")
    assert result.__class__ is Allele, f'Expected parse("B*08:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_134():
    result = parse("B*08:134")
    assert result.__class__ is Allele, f'Expected parse("B*08:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_135():
    result = parse("B*08:135")
    assert result.__class__ is Allele, f'Expected parse("B*08:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_136():
    result = parse("B*08:136")
    assert result.__class__ is Allele, f'Expected parse("B*08:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_137():
    result = parse("B*08:137")
    assert result.__class__ is Allele, f'Expected parse("B*08:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_138():
    result = parse("B*08:138")
    assert result.__class__ is Allele, f'Expected parse("B*08:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_139():
    result = parse("B*08:139")
    assert result.__class__ is Allele, f'Expected parse("B*08:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_14():
    result = parse("B*08:14")
    assert result.__class__ is Allele, f'Expected parse("B*08:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_140():
    result = parse("B*08:140")
    assert result.__class__ is Allele, f'Expected parse("B*08:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_141():
    result = parse("B*08:141")
    assert result.__class__ is Allele, f'Expected parse("B*08:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_142():
    result = parse("B*08:142")
    assert result.__class__ is Allele, f'Expected parse("B*08:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_143():
    result = parse("B*08:143")
    assert result.__class__ is Allele, f'Expected parse("B*08:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_144():
    result = parse("B*08:144")
    assert result.__class__ is Allele, f'Expected parse("B*08:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_145():
    result = parse("B*08:145")
    assert result.__class__ is Allele, f'Expected parse("B*08:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_146():
    result = parse("B*08:146")
    assert result.__class__ is Allele, f'Expected parse("B*08:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_147():
    result = parse("B*08:147")
    assert result.__class__ is Allele, f'Expected parse("B*08:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_148N():
    result = parse("B*08:148N")
    assert result.__class__ is Allele, f'Expected parse("B*08:148N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:148N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_149():
    result = parse("B*08:149")
    assert result.__class__ is Allele, f'Expected parse("B*08:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_15():
    result = parse("B*08:15")
    assert result.__class__ is Allele, f'Expected parse("B*08:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_150():
    result = parse("B*08:150")
    assert result.__class__ is Allele, f'Expected parse("B*08:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_151():
    result = parse("B*08:151")
    assert result.__class__ is Allele, f'Expected parse("B*08:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_152():
    result = parse("B*08:152")
    assert result.__class__ is Allele, f'Expected parse("B*08:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_153():
    result = parse("B*08:153")
    assert result.__class__ is Allele, f'Expected parse("B*08:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_154():
    result = parse("B*08:154")
    assert result.__class__ is Allele, f'Expected parse("B*08:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_155():
    result = parse("B*08:155")
    assert result.__class__ is Allele, f'Expected parse("B*08:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_156():
    result = parse("B*08:156")
    assert result.__class__ is Allele, f'Expected parse("B*08:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_157():
    result = parse("B*08:157")
    assert result.__class__ is Allele, f'Expected parse("B*08:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_158():
    result = parse("B*08:158")
    assert result.__class__ is Allele, f'Expected parse("B*08:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_159():
    result = parse("B*08:159")
    assert result.__class__ is Allele, f'Expected parse("B*08:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_16():
    result = parse("B*08:16")
    assert result.__class__ is Allele, f'Expected parse("B*08:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_160():
    result = parse("B*08:160")
    assert result.__class__ is Allele, f'Expected parse("B*08:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_161():
    result = parse("B*08:161")
    assert result.__class__ is Allele, f'Expected parse("B*08:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_162():
    result = parse("B*08:162")
    assert result.__class__ is Allele, f'Expected parse("B*08:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_163():
    result = parse("B*08:163")
    assert result.__class__ is Allele, f'Expected parse("B*08:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_164():
    result = parse("B*08:164")
    assert result.__class__ is Allele, f'Expected parse("B*08:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_165():
    result = parse("B*08:165")
    assert result.__class__ is Allele, f'Expected parse("B*08:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_166():
    result = parse("B*08:166")
    assert result.__class__ is Allele, f'Expected parse("B*08:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_167():
    result = parse("B*08:167")
    assert result.__class__ is Allele, f'Expected parse("B*08:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_168():
    result = parse("B*08:168")
    assert result.__class__ is Allele, f'Expected parse("B*08:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_169():
    result = parse("B*08:169")
    assert result.__class__ is Allele, f'Expected parse("B*08:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_17():
    result = parse("B*08:17")
    assert result.__class__ is Allele, f'Expected parse("B*08:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_170():
    result = parse("B*08:170")
    assert result.__class__ is Allele, f'Expected parse("B*08:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_171():
    result = parse("B*08:171")
    assert result.__class__ is Allele, f'Expected parse("B*08:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_172():
    result = parse("B*08:172")
    assert result.__class__ is Allele, f'Expected parse("B*08:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_173():
    result = parse("B*08:173")
    assert result.__class__ is Allele, f'Expected parse("B*08:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_174():
    result = parse("B*08:174")
    assert result.__class__ is Allele, f'Expected parse("B*08:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_175():
    result = parse("B*08:175")
    assert result.__class__ is Allele, f'Expected parse("B*08:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_176():
    result = parse("B*08:176")
    assert result.__class__ is Allele, f'Expected parse("B*08:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_177():
    result = parse("B*08:177")
    assert result.__class__ is Allele, f'Expected parse("B*08:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_178():
    result = parse("B*08:178")
    assert result.__class__ is Allele, f'Expected parse("B*08:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_179():
    result = parse("B*08:179")
    assert result.__class__ is Allele, f'Expected parse("B*08:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_18():
    result = parse("B*08:18")
    assert result.__class__ is Allele, f'Expected parse("B*08:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_180():
    result = parse("B*08:180")
    assert result.__class__ is Allele, f'Expected parse("B*08:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_181():
    result = parse("B*08:181")
    assert result.__class__ is Allele, f'Expected parse("B*08:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_182():
    result = parse("B*08:182")
    assert result.__class__ is Allele, f'Expected parse("B*08:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_183():
    result = parse("B*08:183")
    assert result.__class__ is Allele, f'Expected parse("B*08:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_184():
    result = parse("B*08:184")
    assert result.__class__ is Allele, f'Expected parse("B*08:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_185():
    result = parse("B*08:185")
    assert result.__class__ is Allele, f'Expected parse("B*08:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_186():
    result = parse("B*08:186")
    assert result.__class__ is Allele, f'Expected parse("B*08:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_187():
    result = parse("B*08:187")
    assert result.__class__ is Allele, f'Expected parse("B*08:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_188():
    result = parse("B*08:188")
    assert result.__class__ is Allele, f'Expected parse("B*08:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_189():
    result = parse("B*08:189")
    assert result.__class__ is Allele, f'Expected parse("B*08:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_190():
    result = parse("B*08:190")
    assert result.__class__ is Allele, f'Expected parse("B*08:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_191():
    result = parse("B*08:191")
    assert result.__class__ is Allele, f'Expected parse("B*08:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_192():
    result = parse("B*08:192")
    assert result.__class__ is Allele, f'Expected parse("B*08:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_193():
    result = parse("B*08:193")
    assert result.__class__ is Allele, f'Expected parse("B*08:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_194():
    result = parse("B*08:194")
    assert result.__class__ is Allele, f'Expected parse("B*08:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_195():
    result = parse("B*08:195")
    assert result.__class__ is Allele, f'Expected parse("B*08:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_196():
    result = parse("B*08:196")
    assert result.__class__ is Allele, f'Expected parse("B*08:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_197():
    result = parse("B*08:197")
    assert result.__class__ is Allele, f'Expected parse("B*08:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_198():
    result = parse("B*08:198")
    assert result.__class__ is Allele, f'Expected parse("B*08:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_199():
    result = parse("B*08:199")
    assert result.__class__ is Allele, f'Expected parse("B*08:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_19N():
    result = parse("B*08:19N")
    assert result.__class__ is Allele, f'Expected parse("B*08:19N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:19N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_200():
    result = parse("B*08:200")
    assert result.__class__ is Allele, f'Expected parse("B*08:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_201():
    result = parse("B*08:201")
    assert result.__class__ is Allele, f'Expected parse("B*08:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_202():
    result = parse("B*08:202")
    assert result.__class__ is Allele, f'Expected parse("B*08:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_203():
    result = parse("B*08:203")
    assert result.__class__ is Allele, f'Expected parse("B*08:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_204():
    result = parse("B*08:204")
    assert result.__class__ is Allele, f'Expected parse("B*08:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_205():
    result = parse("B*08:205")
    assert result.__class__ is Allele, f'Expected parse("B*08:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_206():
    result = parse("B*08:206")
    assert result.__class__ is Allele, f'Expected parse("B*08:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_207():
    result = parse("B*08:207")
    assert result.__class__ is Allele, f'Expected parse("B*08:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_208():
    result = parse("B*08:208")
    assert result.__class__ is Allele, f'Expected parse("B*08:208") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_209():
    result = parse("B*08:209")
    assert result.__class__ is Allele, f'Expected parse("B*08:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_20_01():
    result = parse("B*08:20:01")
    assert result.__class__ is Allele, f'Expected parse("B*08:20:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:20:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_20_02():
    result = parse("B*08:20:02")
    assert result.__class__ is Allele, f'Expected parse("B*08:20:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:20:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_21():
    result = parse("B*08:21")
    assert result.__class__ is Allele, f'Expected parse("B*08:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_210():
    result = parse("B*08:210")
    assert result.__class__ is Allele, f'Expected parse("B*08:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_211():
    result = parse("B*08:211")
    assert result.__class__ is Allele, f'Expected parse("B*08:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_212():
    result = parse("B*08:212")
    assert result.__class__ is Allele, f'Expected parse("B*08:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_213():
    result = parse("B*08:213")
    assert result.__class__ is Allele, f'Expected parse("B*08:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_214N():
    result = parse("B*08:214N")
    assert result.__class__ is Allele, f'Expected parse("B*08:214N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:214N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_215N():
    result = parse("B*08:215N")
    assert result.__class__ is Allele, f'Expected parse("B*08:215N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:215N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_216():
    result = parse("B*08:216")
    assert result.__class__ is Allele, f'Expected parse("B*08:216") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_217():
    result = parse("B*08:217")
    assert result.__class__ is Allele, f'Expected parse("B*08:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_218():
    result = parse("B*08:218")
    assert result.__class__ is Allele, f'Expected parse("B*08:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_219():
    result = parse("B*08:219")
    assert result.__class__ is Allele, f'Expected parse("B*08:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_22():
    result = parse("B*08:22")
    assert result.__class__ is Allele, f'Expected parse("B*08:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_220N():
    result = parse("B*08:220N")
    assert result.__class__ is Allele, f'Expected parse("B*08:220N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:220N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_221():
    result = parse("B*08:221")
    assert result.__class__ is Allele, f'Expected parse("B*08:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_222():
    result = parse("B*08:222")
    assert result.__class__ is Allele, f'Expected parse("B*08:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_223():
    result = parse("B*08:223")
    assert result.__class__ is Allele, f'Expected parse("B*08:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_224():
    result = parse("B*08:224")
    assert result.__class__ is Allele, f'Expected parse("B*08:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_225():
    result = parse("B*08:225")
    assert result.__class__ is Allele, f'Expected parse("B*08:225") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_226():
    result = parse("B*08:226")
    assert result.__class__ is Allele, f'Expected parse("B*08:226") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_227():
    result = parse("B*08:227")
    assert result.__class__ is Allele, f'Expected parse("B*08:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_228():
    result = parse("B*08:228")
    assert result.__class__ is Allele, f'Expected parse("B*08:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_229():
    result = parse("B*08:229")
    assert result.__class__ is Allele, f'Expected parse("B*08:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_23():
    result = parse("B*08:23")
    assert result.__class__ is Allele, f'Expected parse("B*08:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_230():
    result = parse("B*08:230")
    assert result.__class__ is Allele, f'Expected parse("B*08:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_231():
    result = parse("B*08:231")
    assert result.__class__ is Allele, f'Expected parse("B*08:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_232():
    result = parse("B*08:232")
    assert result.__class__ is Allele, f'Expected parse("B*08:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_233():
    result = parse("B*08:233")
    assert result.__class__ is Allele, f'Expected parse("B*08:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_234():
    result = parse("B*08:234")
    assert result.__class__ is Allele, f'Expected parse("B*08:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_235():
    result = parse("B*08:235")
    assert result.__class__ is Allele, f'Expected parse("B*08:235") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_236N():
    result = parse("B*08:236N")
    assert result.__class__ is Allele, f'Expected parse("B*08:236N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:236N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_237():
    result = parse("B*08:237")
    assert result.__class__ is Allele, f'Expected parse("B*08:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_238():
    result = parse("B*08:238")
    assert result.__class__ is Allele, f'Expected parse("B*08:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_239():
    result = parse("B*08:239")
    assert result.__class__ is Allele, f'Expected parse("B*08:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_24():
    result = parse("B*08:24")
    assert result.__class__ is Allele, f'Expected parse("B*08:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_240():
    result = parse("B*08:240")
    assert result.__class__ is Allele, f'Expected parse("B*08:240") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_241():
    result = parse("B*08:241")
    assert result.__class__ is Allele, f'Expected parse("B*08:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_242():
    result = parse("B*08:242")
    assert result.__class__ is Allele, f'Expected parse("B*08:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_243():
    result = parse("B*08:243")
    assert result.__class__ is Allele, f'Expected parse("B*08:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_244():
    result = parse("B*08:244")
    assert result.__class__ is Allele, f'Expected parse("B*08:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_245():
    result = parse("B*08:245")
    assert result.__class__ is Allele, f'Expected parse("B*08:245") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_246():
    result = parse("B*08:246")
    assert result.__class__ is Allele, f'Expected parse("B*08:246") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_247():
    result = parse("B*08:247")
    assert result.__class__ is Allele, f'Expected parse("B*08:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_248():
    result = parse("B*08:248")
    assert result.__class__ is Allele, f'Expected parse("B*08:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_249():
    result = parse("B*08:249")
    assert result.__class__ is Allele, f'Expected parse("B*08:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_25():
    result = parse("B*08:25")
    assert result.__class__ is Allele, f'Expected parse("B*08:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_250():
    result = parse("B*08:250")
    assert result.__class__ is Allele, f'Expected parse("B*08:250") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_251():
    result = parse("B*08:251")
    assert result.__class__ is Allele, f'Expected parse("B*08:251") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_252N():
    result = parse("B*08:252N")
    assert result.__class__ is Allele, f'Expected parse("B*08:252N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:252N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_253():
    result = parse("B*08:253")
    assert result.__class__ is Allele, f'Expected parse("B*08:253") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_254():
    result = parse("B*08:254")
    assert result.__class__ is Allele, f'Expected parse("B*08:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_255():
    result = parse("B*08:255")
    assert result.__class__ is Allele, f'Expected parse("B*08:255") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_256():
    result = parse("B*08:256")
    assert result.__class__ is Allele, f'Expected parse("B*08:256") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_257():
    result = parse("B*08:257")
    assert result.__class__ is Allele, f'Expected parse("B*08:257") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_258():
    result = parse("B*08:258")
    assert result.__class__ is Allele, f'Expected parse("B*08:258") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_259():
    result = parse("B*08:259")
    assert result.__class__ is Allele, f'Expected parse("B*08:259") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_260():
    result = parse("B*08:260")
    assert result.__class__ is Allele, f'Expected parse("B*08:260") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_261():
    result = parse("B*08:261")
    assert result.__class__ is Allele, f'Expected parse("B*08:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_262():
    result = parse("B*08:262")
    assert result.__class__ is Allele, f'Expected parse("B*08:262") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_26_01():
    result = parse("B*08:26:01")
    assert result.__class__ is Allele, f'Expected parse("B*08:26:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:26:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_26_02():
    result = parse("B*08:26:02")
    assert result.__class__ is Allele, f'Expected parse("B*08:26:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:26:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_26_03():
    result = parse("B*08:26:03")
    assert result.__class__ is Allele, f'Expected parse("B*08:26:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:26:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_27():
    result = parse("B*08:27")
    assert result.__class__ is Allele, f'Expected parse("B*08:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_28():
    result = parse("B*08:28")
    assert result.__class__ is Allele, f'Expected parse("B*08:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_29():
    result = parse("B*08:29")
    assert result.__class__ is Allele, f'Expected parse("B*08:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_30N():
    result = parse("B*08:30N")
    assert result.__class__ is Allele, f'Expected parse("B*08:30N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:30N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_31():
    result = parse("B*08:31")
    assert result.__class__ is Allele, f'Expected parse("B*08:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_32():
    result = parse("B*08:32")
    assert result.__class__ is Allele, f'Expected parse("B*08:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_33():
    result = parse("B*08:33")
    assert result.__class__ is Allele, f'Expected parse("B*08:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_34():
    result = parse("B*08:34")
    assert result.__class__ is Allele, f'Expected parse("B*08:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_35():
    result = parse("B*08:35")
    assert result.__class__ is Allele, f'Expected parse("B*08:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_36():
    result = parse("B*08:36")
    assert result.__class__ is Allele, f'Expected parse("B*08:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_37():
    result = parse("B*08:37")
    assert result.__class__ is Allele, f'Expected parse("B*08:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_38_01():
    result = parse("B*08:38:01")
    assert result.__class__ is Allele, f'Expected parse("B*08:38:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:38:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_38_02():
    result = parse("B*08:38:02")
    assert result.__class__ is Allele, f'Expected parse("B*08:38:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:38:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_39():
    result = parse("B*08:39")
    assert result.__class__ is Allele, f'Expected parse("B*08:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_40():
    result = parse("B*08:40")
    assert result.__class__ is Allele, f'Expected parse("B*08:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_41():
    result = parse("B*08:41")
    assert result.__class__ is Allele, f'Expected parse("B*08:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_42():
    result = parse("B*08:42")
    assert result.__class__ is Allele, f'Expected parse("B*08:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_43():
    result = parse("B*08:43")
    assert result.__class__ is Allele, f'Expected parse("B*08:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_44():
    result = parse("B*08:44")
    assert result.__class__ is Allele, f'Expected parse("B*08:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_45():
    result = parse("B*08:45")
    assert result.__class__ is Allele, f'Expected parse("B*08:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_46():
    result = parse("B*08:46")
    assert result.__class__ is Allele, f'Expected parse("B*08:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_47():
    result = parse("B*08:47")
    assert result.__class__ is Allele, f'Expected parse("B*08:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_48():
    result = parse("B*08:48")
    assert result.__class__ is Allele, f'Expected parse("B*08:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_49():
    result = parse("B*08:49")
    assert result.__class__ is Allele, f'Expected parse("B*08:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_50():
    result = parse("B*08:50")
    assert result.__class__ is Allele, f'Expected parse("B*08:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_51():
    result = parse("B*08:51")
    assert result.__class__ is Allele, f'Expected parse("B*08:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_52():
    result = parse("B*08:52")
    assert result.__class__ is Allele, f'Expected parse("B*08:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_53_01():
    result = parse("B*08:53:01")
    assert result.__class__ is Allele, f'Expected parse("B*08:53:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:53:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_53_02():
    result = parse("B*08:53:02")
    assert result.__class__ is Allele, f'Expected parse("B*08:53:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:53:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_54_01():
    result = parse("B*08:54:01")
    assert result.__class__ is Allele, f'Expected parse("B*08:54:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:54:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_54_02():
    result = parse("B*08:54:02")
    assert result.__class__ is Allele, f'Expected parse("B*08:54:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:54:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_55():
    result = parse("B*08:55")
    assert result.__class__ is Allele, f'Expected parse("B*08:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_56_01():
    result = parse("B*08:56:01")
    assert result.__class__ is Allele, f'Expected parse("B*08:56:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:56:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_56_02():
    result = parse("B*08:56:02")
    assert result.__class__ is Allele, f'Expected parse("B*08:56:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:56:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_56_03():
    result = parse("B*08:56:03")
    assert result.__class__ is Allele, f'Expected parse("B*08:56:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:56:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_57():
    result = parse("B*08:57")
    assert result.__class__ is Allele, f'Expected parse("B*08:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_58():
    result = parse("B*08:58")
    assert result.__class__ is Allele, f'Expected parse("B*08:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_59_01():
    result = parse("B*08:59:01")
    assert result.__class__ is Allele, f'Expected parse("B*08:59:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:59:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_59_02():
    result = parse("B*08:59:02")
    assert result.__class__ is Allele, f'Expected parse("B*08:59:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:59:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_60():
    result = parse("B*08:60")
    assert result.__class__ is Allele, f'Expected parse("B*08:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_61():
    result = parse("B*08:61")
    assert result.__class__ is Allele, f'Expected parse("B*08:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_62():
    result = parse("B*08:62")
    assert result.__class__ is Allele, f'Expected parse("B*08:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_63():
    result = parse("B*08:63")
    assert result.__class__ is Allele, f'Expected parse("B*08:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_64():
    result = parse("B*08:64")
    assert result.__class__ is Allele, f'Expected parse("B*08:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_65():
    result = parse("B*08:65")
    assert result.__class__ is Allele, f'Expected parse("B*08:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_66():
    result = parse("B*08:66")
    assert result.__class__ is Allele, f'Expected parse("B*08:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_67_01N():
    result = parse("B*08:67:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:67:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:67:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_67_02N():
    result = parse("B*08:67:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("B*08:67:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:67:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_68():
    result = parse("B*08:68")
    assert result.__class__ is Allele, f'Expected parse("B*08:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_69():
    result = parse("B*08:69")
    assert result.__class__ is Allele, f'Expected parse("B*08:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_70():
    result = parse("B*08:70")
    assert result.__class__ is Allele, f'Expected parse("B*08:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_71():
    result = parse("B*08:71")
    assert result.__class__ is Allele, f'Expected parse("B*08:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_72N():
    result = parse("B*08:72N")
    assert result.__class__ is Allele, f'Expected parse("B*08:72N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:72N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_73():
    result = parse("B*08:73")
    assert result.__class__ is Allele, f'Expected parse("B*08:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_74():
    result = parse("B*08:74")
    assert result.__class__ is Allele, f'Expected parse("B*08:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_75():
    result = parse("B*08:75")
    assert result.__class__ is Allele, f'Expected parse("B*08:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_76():
    result = parse("B*08:76")
    assert result.__class__ is Allele, f'Expected parse("B*08:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_77():
    result = parse("B*08:77")
    assert result.__class__ is Allele, f'Expected parse("B*08:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_78():
    result = parse("B*08:78")
    assert result.__class__ is Allele, f'Expected parse("B*08:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_79():
    result = parse("B*08:79")
    assert result.__class__ is Allele, f'Expected parse("B*08:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_80():
    result = parse("B*08:80")
    assert result.__class__ is Allele, f'Expected parse("B*08:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_81():
    result = parse("B*08:81")
    assert result.__class__ is Allele, f'Expected parse("B*08:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_82N():
    result = parse("B*08:82N")
    assert result.__class__ is Allele, f'Expected parse("B*08:82N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:82N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_83():
    result = parse("B*08:83")
    assert result.__class__ is Allele, f'Expected parse("B*08:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_84():
    result = parse("B*08:84")
    assert result.__class__ is Allele, f'Expected parse("B*08:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_85():
    result = parse("B*08:85")
    assert result.__class__ is Allele, f'Expected parse("B*08:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_86N():
    result = parse("B*08:86N")
    assert result.__class__ is Allele, f'Expected parse("B*08:86N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:86N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_87():
    result = parse("B*08:87")
    assert result.__class__ is Allele, f'Expected parse("B*08:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_88():
    result = parse("B*08:88")
    assert result.__class__ is Allele, f'Expected parse("B*08:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_89():
    result = parse("B*08:89")
    assert result.__class__ is Allele, f'Expected parse("B*08:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_90():
    result = parse("B*08:90")
    assert result.__class__ is Allele, f'Expected parse("B*08:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_91():
    result = parse("B*08:91")
    assert result.__class__ is Allele, f'Expected parse("B*08:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_92():
    result = parse("B*08:92")
    assert result.__class__ is Allele, f'Expected parse("B*08:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_93():
    result = parse("B*08:93")
    assert result.__class__ is Allele, f'Expected parse("B*08:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_94():
    result = parse("B*08:94")
    assert result.__class__ is Allele, f'Expected parse("B*08:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_95():
    result = parse("B*08:95")
    assert result.__class__ is Allele, f'Expected parse("B*08:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_96_01():
    result = parse("B*08:96:01")
    assert result.__class__ is Allele, f'Expected parse("B*08:96:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:96:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_96_02():
    result = parse("B*08:96:02")
    assert result.__class__ is Allele, f'Expected parse("B*08:96:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*08:96:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_97():
    result = parse("B*08:97")
    assert result.__class__ is Allele, f'Expected parse("B*08:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_98():
    result = parse("B*08:98")
    assert result.__class__ is Allele, f'Expected parse("B*08:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_08_99():
    result = parse("B*08:99")
    assert result.__class__ is Allele, f'Expected parse("B*08:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*08:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_01_01():
    result = parse("B*13:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_01_02():
    result = parse("B*13:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_01_03():
    result = parse("B*13:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_01_04():
    result = parse("B*13:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_01_05():
    result = parse("B*13:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_01_06():
    result = parse("B*13:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_01_07():
    result = parse("B*13:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_02():
    result = parse("B*13:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*13:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_03():
    result = parse("B*13:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*13:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_04():
    result = parse("B*13:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*13:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_05():
    result = parse("B*13:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*13:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_06():
    result = parse("B*13:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*13:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_07():
    result = parse("B*13:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*13:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_08():
    result = parse("B*13:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*13:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_09():
    result = parse("B*13:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*13:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_10():
    result = parse("B*13:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*13:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_11():
    result = parse("B*13:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*13:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_12():
    result = parse("B*13:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*13:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_13():
    result = parse("B*13:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*13:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_14():
    result = parse("B*13:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*13:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_15():
    result = parse("B*13:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*13:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_16():
    result = parse("B*13:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*13:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_01_17():
    result = parse("B*13:01:17")
    assert result.__class__ is Allele, f'Expected parse("B*13:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_01_01():
    result = parse("B*13:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_01_02():
    result = parse("B*13:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_01_03():
    result = parse("B*13:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_01_04():
    result = parse("B*13:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_01_05():
    result = parse("B*13:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_01_06():
    result = parse("B*13:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_01_07():
    result = parse("B*13:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_01_08():
    result = parse("B*13:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_01_09():
    result = parse("B*13:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_01_10():
    result = parse("B*13:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_01_11():
    result = parse("B*13:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_01_12():
    result = parse("B*13:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_01_13():
    result = parse("B*13:02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:02:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_01_14():
    result = parse("B*13:02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*13:02:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_02():
    result = parse("B*13:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_03():
    result = parse("B*13:02:03")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_04():
    result = parse("B*13:02:04")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_05():
    result = parse("B*13:02:05")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_06():
    result = parse("B*13:02:06")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_07():
    result = parse("B*13:02:07")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_08():
    result = parse("B*13:02:08")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_09():
    result = parse("B*13:02:09")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_10():
    result = parse("B*13:02:10")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_11():
    result = parse("B*13:02:11")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_12():
    result = parse("B*13:02:12")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_13():
    result = parse("B*13:02:13")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_14():
    result = parse("B*13:02:14")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_15():
    result = parse("B*13:02:15")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_16():
    result = parse("B*13:02:16")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_17():
    result = parse("B*13:02:17")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_18():
    result = parse("B*13:02:18")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_19():
    result = parse("B*13:02:19")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_20():
    result = parse("B*13:02:20")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_21():
    result = parse("B*13:02:21")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_22():
    result = parse("B*13:02:22")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_23():
    result = parse("B*13:02:23")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_24():
    result = parse("B*13:02:24")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_25():
    result = parse("B*13:02:25")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_26():
    result = parse("B*13:02:26")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_27():
    result = parse("B*13:02:27")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_28():
    result = parse("B*13:02:28")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_29():
    result = parse("B*13:02:29")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_30():
    result = parse("B*13:02:30")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_31():
    result = parse("B*13:02:31")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_02_32():
    result = parse("B*13:02:32")
    assert result.__class__ is Allele, f'Expected parse("B*13:02:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:02:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_03():
    result = parse("B*13:03")
    assert result.__class__ is Allele, f'Expected parse("B*13:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_04():
    result = parse("B*13:04")
    assert result.__class__ is Allele, f'Expected parse("B*13:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_06():
    result = parse("B*13:06")
    assert result.__class__ is Allele, f'Expected parse("B*13:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_07N():
    result = parse("B*13:07N")
    assert result.__class__ is Allele, f'Expected parse("B*13:07N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:07N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_08():
    result = parse("B*13:08")
    assert result.__class__ is Allele, f'Expected parse("B*13:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_09():
    result = parse("B*13:09")
    assert result.__class__ is Allele, f'Expected parse("B*13:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_10():
    result = parse("B*13:10")
    assert result.__class__ is Allele, f'Expected parse("B*13:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_100():
    result = parse("B*13:100")
    assert result.__class__ is Allele, f'Expected parse("B*13:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_101():
    result = parse("B*13:101")
    assert result.__class__ is Allele, f'Expected parse("B*13:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_102():
    result = parse("B*13:102")
    assert result.__class__ is Allele, f'Expected parse("B*13:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_103N():
    result = parse("B*13:103N")
    assert result.__class__ is Allele, f'Expected parse("B*13:103N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:103N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_104():
    result = parse("B*13:104")
    assert result.__class__ is Allele, f'Expected parse("B*13:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_105():
    result = parse("B*13:105")
    assert result.__class__ is Allele, f'Expected parse("B*13:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_106():
    result = parse("B*13:106")
    assert result.__class__ is Allele, f'Expected parse("B*13:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_107():
    result = parse("B*13:107")
    assert result.__class__ is Allele, f'Expected parse("B*13:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_108():
    result = parse("B*13:108")
    assert result.__class__ is Allele, f'Expected parse("B*13:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_109():
    result = parse("B*13:109")
    assert result.__class__ is Allele, f'Expected parse("B*13:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_11():
    result = parse("B*13:11")
    assert result.__class__ is Allele, f'Expected parse("B*13:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_110():
    result = parse("B*13:110")
    assert result.__class__ is Allele, f'Expected parse("B*13:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_111():
    result = parse("B*13:111")
    assert result.__class__ is Allele, f'Expected parse("B*13:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_112():
    result = parse("B*13:112")
    assert result.__class__ is Allele, f'Expected parse("B*13:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_113():
    result = parse("B*13:113")
    assert result.__class__ is Allele, f'Expected parse("B*13:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_114():
    result = parse("B*13:114")
    assert result.__class__ is Allele, f'Expected parse("B*13:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_115():
    result = parse("B*13:115")
    assert result.__class__ is Allele, f'Expected parse("B*13:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_116N():
    result = parse("B*13:116N")
    assert result.__class__ is Allele, f'Expected parse("B*13:116N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:116N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_117():
    result = parse("B*13:117")
    assert result.__class__ is Allele, f'Expected parse("B*13:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_118():
    result = parse("B*13:118")
    assert result.__class__ is Allele, f'Expected parse("B*13:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_119():
    result = parse("B*13:119")
    assert result.__class__ is Allele, f'Expected parse("B*13:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_120():
    result = parse("B*13:120")
    assert result.__class__ is Allele, f'Expected parse("B*13:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_121():
    result = parse("B*13:121")
    assert result.__class__ is Allele, f'Expected parse("B*13:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_122():
    result = parse("B*13:122")
    assert result.__class__ is Allele, f'Expected parse("B*13:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_123Q():
    result = parse("B*13:123Q")
    assert result.__class__ is Allele, f'Expected parse("B*13:123Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:123Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_124():
    result = parse("B*13:124")
    assert result.__class__ is Allele, f'Expected parse("B*13:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_125():
    result = parse("B*13:125")
    assert result.__class__ is Allele, f'Expected parse("B*13:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_126():
    result = parse("B*13:126")
    assert result.__class__ is Allele, f'Expected parse("B*13:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_127():
    result = parse("B*13:127")
    assert result.__class__ is Allele, f'Expected parse("B*13:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_128():
    result = parse("B*13:128")
    assert result.__class__ is Allele, f'Expected parse("B*13:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_129():
    result = parse("B*13:129")
    assert result.__class__ is Allele, f'Expected parse("B*13:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_12_01():
    result = parse("B*13:12:01")
    assert result.__class__ is Allele, f'Expected parse("B*13:12:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:12:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_12_02():
    result = parse("B*13:12:02")
    assert result.__class__ is Allele, f'Expected parse("B*13:12:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:12:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_130():
    result = parse("B*13:130")
    assert result.__class__ is Allele, f'Expected parse("B*13:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_131():
    result = parse("B*13:131")
    assert result.__class__ is Allele, f'Expected parse("B*13:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_132():
    result = parse("B*13:132")
    assert result.__class__ is Allele, f'Expected parse("B*13:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_133():
    result = parse("B*13:133")
    assert result.__class__ is Allele, f'Expected parse("B*13:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_134():
    result = parse("B*13:134")
    assert result.__class__ is Allele, f'Expected parse("B*13:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_135():
    result = parse("B*13:135")
    assert result.__class__ is Allele, f'Expected parse("B*13:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_136():
    result = parse("B*13:136")
    assert result.__class__ is Allele, f'Expected parse("B*13:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_137N():
    result = parse("B*13:137N")
    assert result.__class__ is Allele, f'Expected parse("B*13:137N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:137N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_138():
    result = parse("B*13:138")
    assert result.__class__ is Allele, f'Expected parse("B*13:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_139N():
    result = parse("B*13:139N")
    assert result.__class__ is Allele, f'Expected parse("B*13:139N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:139N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_13_01():
    result = parse("B*13:13:01")
    assert result.__class__ is Allele, f'Expected parse("B*13:13:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:13:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_13_02():
    result = parse("B*13:13:02")
    assert result.__class__ is Allele, f'Expected parse("B*13:13:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:13:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_14():
    result = parse("B*13:14")
    assert result.__class__ is Allele, f'Expected parse("B*13:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_140():
    result = parse("B*13:140")
    assert result.__class__ is Allele, f'Expected parse("B*13:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_141():
    result = parse("B*13:141")
    assert result.__class__ is Allele, f'Expected parse("B*13:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_142():
    result = parse("B*13:142")
    assert result.__class__ is Allele, f'Expected parse("B*13:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_143():
    result = parse("B*13:143")
    assert result.__class__ is Allele, f'Expected parse("B*13:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_15():
    result = parse("B*13:15")
    assert result.__class__ is Allele, f'Expected parse("B*13:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_16():
    result = parse("B*13:16")
    assert result.__class__ is Allele, f'Expected parse("B*13:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_17():
    result = parse("B*13:17")
    assert result.__class__ is Allele, f'Expected parse("B*13:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_18():
    result = parse("B*13:18")
    assert result.__class__ is Allele, f'Expected parse("B*13:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_19():
    result = parse("B*13:19")
    assert result.__class__ is Allele, f'Expected parse("B*13:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_20():
    result = parse("B*13:20")
    assert result.__class__ is Allele, f'Expected parse("B*13:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_21():
    result = parse("B*13:21")
    assert result.__class__ is Allele, f'Expected parse("B*13:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_22_01():
    result = parse("B*13:22:01")
    assert result.__class__ is Allele, f'Expected parse("B*13:22:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:22:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_22_02():
    result = parse("B*13:22:02")
    assert result.__class__ is Allele, f'Expected parse("B*13:22:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:22:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_23():
    result = parse("B*13:23")
    assert result.__class__ is Allele, f'Expected parse("B*13:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_25():
    result = parse("B*13:25")
    assert result.__class__ is Allele, f'Expected parse("B*13:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_26_01():
    result = parse("B*13:26:01")
    assert result.__class__ is Allele, f'Expected parse("B*13:26:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:26:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_26_02():
    result = parse("B*13:26:02")
    assert result.__class__ is Allele, f'Expected parse("B*13:26:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:26:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_27():
    result = parse("B*13:27")
    assert result.__class__ is Allele, f'Expected parse("B*13:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_28():
    result = parse("B*13:28")
    assert result.__class__ is Allele, f'Expected parse("B*13:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_29():
    result = parse("B*13:29")
    assert result.__class__ is Allele, f'Expected parse("B*13:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_30():
    result = parse("B*13:30")
    assert result.__class__ is Allele, f'Expected parse("B*13:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_31():
    result = parse("B*13:31")
    assert result.__class__ is Allele, f'Expected parse("B*13:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_32():
    result = parse("B*13:32")
    assert result.__class__ is Allele, f'Expected parse("B*13:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_33():
    result = parse("B*13:33")
    assert result.__class__ is Allele, f'Expected parse("B*13:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_34():
    result = parse("B*13:34")
    assert result.__class__ is Allele, f'Expected parse("B*13:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_35():
    result = parse("B*13:35")
    assert result.__class__ is Allele, f'Expected parse("B*13:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_36():
    result = parse("B*13:36")
    assert result.__class__ is Allele, f'Expected parse("B*13:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_37():
    result = parse("B*13:37")
    assert result.__class__ is Allele, f'Expected parse("B*13:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_38():
    result = parse("B*13:38")
    assert result.__class__ is Allele, f'Expected parse("B*13:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_39():
    result = parse("B*13:39")
    assert result.__class__ is Allele, f'Expected parse("B*13:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_40():
    result = parse("B*13:40")
    assert result.__class__ is Allele, f'Expected parse("B*13:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_41():
    result = parse("B*13:41")
    assert result.__class__ is Allele, f'Expected parse("B*13:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_42():
    result = parse("B*13:42")
    assert result.__class__ is Allele, f'Expected parse("B*13:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_43():
    result = parse("B*13:43")
    assert result.__class__ is Allele, f'Expected parse("B*13:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_44():
    result = parse("B*13:44")
    assert result.__class__ is Allele, f'Expected parse("B*13:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_45():
    result = parse("B*13:45")
    assert result.__class__ is Allele, f'Expected parse("B*13:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_46():
    result = parse("B*13:46")
    assert result.__class__ is Allele, f'Expected parse("B*13:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_47():
    result = parse("B*13:47")
    assert result.__class__ is Allele, f'Expected parse("B*13:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_48():
    result = parse("B*13:48")
    assert result.__class__ is Allele, f'Expected parse("B*13:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_49N():
    result = parse("B*13:49N")
    assert result.__class__ is Allele, f'Expected parse("B*13:49N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:49N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_50():
    result = parse("B*13:50")
    assert result.__class__ is Allele, f'Expected parse("B*13:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_51():
    result = parse("B*13:51")
    assert result.__class__ is Allele, f'Expected parse("B*13:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_52():
    result = parse("B*13:52")
    assert result.__class__ is Allele, f'Expected parse("B*13:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_53():
    result = parse("B*13:53")
    assert result.__class__ is Allele, f'Expected parse("B*13:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_54():
    result = parse("B*13:54")
    assert result.__class__ is Allele, f'Expected parse("B*13:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_55():
    result = parse("B*13:55")
    assert result.__class__ is Allele, f'Expected parse("B*13:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_56_01N():
    result = parse("B*13:56:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:56:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:56:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_56_02N():
    result = parse("B*13:56:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("B*13:56:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*13:56:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_57():
    result = parse("B*13:57")
    assert result.__class__ is Allele, f'Expected parse("B*13:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_58():
    result = parse("B*13:58")
    assert result.__class__ is Allele, f'Expected parse("B*13:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_59():
    result = parse("B*13:59")
    assert result.__class__ is Allele, f'Expected parse("B*13:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_60():
    result = parse("B*13:60")
    assert result.__class__ is Allele, f'Expected parse("B*13:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_61():
    result = parse("B*13:61")
    assert result.__class__ is Allele, f'Expected parse("B*13:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_62():
    result = parse("B*13:62")
    assert result.__class__ is Allele, f'Expected parse("B*13:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_63N():
    result = parse("B*13:63N")
    assert result.__class__ is Allele, f'Expected parse("B*13:63N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:63N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_64():
    result = parse("B*13:64")
    assert result.__class__ is Allele, f'Expected parse("B*13:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_65():
    result = parse("B*13:65")
    assert result.__class__ is Allele, f'Expected parse("B*13:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_66():
    result = parse("B*13:66")
    assert result.__class__ is Allele, f'Expected parse("B*13:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_67():
    result = parse("B*13:67")
    assert result.__class__ is Allele, f'Expected parse("B*13:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_68():
    result = parse("B*13:68")
    assert result.__class__ is Allele, f'Expected parse("B*13:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_69():
    result = parse("B*13:69")
    assert result.__class__ is Allele, f'Expected parse("B*13:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_70():
    result = parse("B*13:70")
    assert result.__class__ is Allele, f'Expected parse("B*13:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_71():
    result = parse("B*13:71")
    assert result.__class__ is Allele, f'Expected parse("B*13:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_72():
    result = parse("B*13:72")
    assert result.__class__ is Allele, f'Expected parse("B*13:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_73():
    result = parse("B*13:73")
    assert result.__class__ is Allele, f'Expected parse("B*13:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_74():
    result = parse("B*13:74")
    assert result.__class__ is Allele, f'Expected parse("B*13:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_75():
    result = parse("B*13:75")
    assert result.__class__ is Allele, f'Expected parse("B*13:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_76N():
    result = parse("B*13:76N")
    assert result.__class__ is Allele, f'Expected parse("B*13:76N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:76N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_77():
    result = parse("B*13:77")
    assert result.__class__ is Allele, f'Expected parse("B*13:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_78():
    result = parse("B*13:78")
    assert result.__class__ is Allele, f'Expected parse("B*13:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_79():
    result = parse("B*13:79")
    assert result.__class__ is Allele, f'Expected parse("B*13:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_80():
    result = parse("B*13:80")
    assert result.__class__ is Allele, f'Expected parse("B*13:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_81():
    result = parse("B*13:81")
    assert result.__class__ is Allele, f'Expected parse("B*13:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_82():
    result = parse("B*13:82")
    assert result.__class__ is Allele, f'Expected parse("B*13:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_83():
    result = parse("B*13:83")
    assert result.__class__ is Allele, f'Expected parse("B*13:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_84():
    result = parse("B*13:84")
    assert result.__class__ is Allele, f'Expected parse("B*13:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_85():
    result = parse("B*13:85")
    assert result.__class__ is Allele, f'Expected parse("B*13:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_86():
    result = parse("B*13:86")
    assert result.__class__ is Allele, f'Expected parse("B*13:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_87():
    result = parse("B*13:87")
    assert result.__class__ is Allele, f'Expected parse("B*13:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_88():
    result = parse("B*13:88")
    assert result.__class__ is Allele, f'Expected parse("B*13:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_89():
    result = parse("B*13:89")
    assert result.__class__ is Allele, f'Expected parse("B*13:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_90():
    result = parse("B*13:90")
    assert result.__class__ is Allele, f'Expected parse("B*13:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_91():
    result = parse("B*13:91")
    assert result.__class__ is Allele, f'Expected parse("B*13:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_92():
    result = parse("B*13:92")
    assert result.__class__ is Allele, f'Expected parse("B*13:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_93():
    result = parse("B*13:93")
    assert result.__class__ is Allele, f'Expected parse("B*13:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_94():
    result = parse("B*13:94")
    assert result.__class__ is Allele, f'Expected parse("B*13:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_95():
    result = parse("B*13:95")
    assert result.__class__ is Allele, f'Expected parse("B*13:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_96():
    result = parse("B*13:96")
    assert result.__class__ is Allele, f'Expected parse("B*13:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_97():
    result = parse("B*13:97")
    assert result.__class__ is Allele, f'Expected parse("B*13:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_98():
    result = parse("B*13:98")
    assert result.__class__ is Allele, f'Expected parse("B*13:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_13_99():
    result = parse("B*13:99")
    assert result.__class__ is Allele, f'Expected parse("B*13:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*13:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_01_01_01():
    result = parse("B*14:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_01_01_02():
    result = parse("B*14:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_01_01_03():
    result = parse("B*14:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_01_01_04():
    result = parse("B*14:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_01_01_05():
    result = parse("B*14:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_01_01_06():
    result = parse("B*14:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_01_01_07():
    result = parse("B*14:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_01_02():
    result = parse("B*14:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*14:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_01_03():
    result = parse("B*14:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*14:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_01_04():
    result = parse("B*14:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*14:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_01_05():
    result = parse("B*14:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*14:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_01_06():
    result = parse("B*14:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*14:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_01_07():
    result = parse("B*14:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*14:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_01_08():
    result = parse("B*14:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*14:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_01_09():
    result = parse("B*14:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*14:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_01_10():
    result = parse("B*14:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*14:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_01():
    result = parse("B*14:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_02():
    result = parse("B*14:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_03():
    result = parse("B*14:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_04():
    result = parse("B*14:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_05():
    result = parse("B*14:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_06():
    result = parse("B*14:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_07():
    result = parse("B*14:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_08():
    result = parse("B*14:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_09():
    result = parse("B*14:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_10():
    result = parse("B*14:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_11():
    result = parse("B*14:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_12():
    result = parse("B*14:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_13():
    result = parse("B*14:02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_14():
    result = parse("B*14:02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_15():
    result = parse("B*14:02:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_16():
    result = parse("B*14:02:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_17():
    result = parse("B*14:02:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_18():
    result = parse("B*14:02:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_01_19():
    result = parse("B*14:02:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("B*14:02:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*14:02:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_02():
    result = parse("B*14:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_03():
    result = parse("B*14:02:03")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_04():
    result = parse("B*14:02:04")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_05():
    result = parse("B*14:02:05")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_06():
    result = parse("B*14:02:06")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_07():
    result = parse("B*14:02:07")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_08():
    result = parse("B*14:02:08")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_09():
    result = parse("B*14:02:09")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_10():
    result = parse("B*14:02:10")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_11():
    result = parse("B*14:02:11")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_12():
    result = parse("B*14:02:12")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_13():
    result = parse("B*14:02:13")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_14():
    result = parse("B*14:02:14")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_15():
    result = parse("B*14:02:15")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_16():
    result = parse("B*14:02:16")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_17():
    result = parse("B*14:02:17")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_18():
    result = parse("B*14:02:18")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_19():
    result = parse("B*14:02:19")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_20():
    result = parse("B*14:02:20")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_21():
    result = parse("B*14:02:21")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_22():
    result = parse("B*14:02:22")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_23():
    result = parse("B*14:02:23")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_24():
    result = parse("B*14:02:24")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_25():
    result = parse("B*14:02:25")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_02_26():
    result = parse("B*14:02:26")
    assert result.__class__ is Allele, f'Expected parse("B*14:02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_03():
    result = parse("B*14:03")
    assert result.__class__ is Allele, f'Expected parse("B*14:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_04():
    result = parse("B*14:04")
    assert result.__class__ is Allele, f'Expected parse("B*14:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_05():
    result = parse("B*14:05")
    assert result.__class__ is Allele, f'Expected parse("B*14:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_06_01():
    result = parse("B*14:06:01")
    assert result.__class__ is Allele, f'Expected parse("B*14:06:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_06_02():
    result = parse("B*14:06:02")
    assert result.__class__ is Allele, f'Expected parse("B*14:06:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_07N():
    result = parse("B*14:07N")
    assert result.__class__ is Allele, f'Expected parse("B*14:07N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:07N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_08_01():
    result = parse("B*14:08:01")
    assert result.__class__ is Allele, f'Expected parse("B*14:08:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:08:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_08_02():
    result = parse("B*14:08:02")
    assert result.__class__ is Allele, f'Expected parse("B*14:08:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*14:08:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_09():
    result = parse("B*14:09")
    assert result.__class__ is Allele, f'Expected parse("B*14:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_10():
    result = parse("B*14:10")
    assert result.__class__ is Allele, f'Expected parse("B*14:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_11():
    result = parse("B*14:11")
    assert result.__class__ is Allele, f'Expected parse("B*14:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_12():
    result = parse("B*14:12")
    assert result.__class__ is Allele, f'Expected parse("B*14:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_13():
    result = parse("B*14:13")
    assert result.__class__ is Allele, f'Expected parse("B*14:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_14():
    result = parse("B*14:14")
    assert result.__class__ is Allele, f'Expected parse("B*14:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_15():
    result = parse("B*14:15")
    assert result.__class__ is Allele, f'Expected parse("B*14:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_16():
    result = parse("B*14:16")
    assert result.__class__ is Allele, f'Expected parse("B*14:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_17():
    result = parse("B*14:17")
    assert result.__class__ is Allele, f'Expected parse("B*14:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_18():
    result = parse("B*14:18")
    assert result.__class__ is Allele, f'Expected parse("B*14:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_19():
    result = parse("B*14:19")
    assert result.__class__ is Allele, f'Expected parse("B*14:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_20():
    result = parse("B*14:20")
    assert result.__class__ is Allele, f'Expected parse("B*14:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_21():
    result = parse("B*14:21")
    assert result.__class__ is Allele, f'Expected parse("B*14:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_22():
    result = parse("B*14:22")
    assert result.__class__ is Allele, f'Expected parse("B*14:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_23():
    result = parse("B*14:23")
    assert result.__class__ is Allele, f'Expected parse("B*14:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_24():
    result = parse("B*14:24")
    assert result.__class__ is Allele, f'Expected parse("B*14:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_25():
    result = parse("B*14:25")
    assert result.__class__ is Allele, f'Expected parse("B*14:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_26():
    result = parse("B*14:26")
    assert result.__class__ is Allele, f'Expected parse("B*14:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_27():
    result = parse("B*14:27")
    assert result.__class__ is Allele, f'Expected parse("B*14:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_28():
    result = parse("B*14:28")
    assert result.__class__ is Allele, f'Expected parse("B*14:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_29():
    result = parse("B*14:29")
    assert result.__class__ is Allele, f'Expected parse("B*14:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_30():
    result = parse("B*14:30")
    assert result.__class__ is Allele, f'Expected parse("B*14:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_31():
    result = parse("B*14:31")
    assert result.__class__ is Allele, f'Expected parse("B*14:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_32():
    result = parse("B*14:32")
    assert result.__class__ is Allele, f'Expected parse("B*14:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_33():
    result = parse("B*14:33")
    assert result.__class__ is Allele, f'Expected parse("B*14:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_34():
    result = parse("B*14:34")
    assert result.__class__ is Allele, f'Expected parse("B*14:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_35():
    result = parse("B*14:35")
    assert result.__class__ is Allele, f'Expected parse("B*14:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_36():
    result = parse("B*14:36")
    assert result.__class__ is Allele, f'Expected parse("B*14:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_37():
    result = parse("B*14:37")
    assert result.__class__ is Allele, f'Expected parse("B*14:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_38():
    result = parse("B*14:38")
    assert result.__class__ is Allele, f'Expected parse("B*14:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_39():
    result = parse("B*14:39")
    assert result.__class__ is Allele, f'Expected parse("B*14:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_40():
    result = parse("B*14:40")
    assert result.__class__ is Allele, f'Expected parse("B*14:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_41N():
    result = parse("B*14:41N")
    assert result.__class__ is Allele, f'Expected parse("B*14:41N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:41N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_42():
    result = parse("B*14:42")
    assert result.__class__ is Allele, f'Expected parse("B*14:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_43():
    result = parse("B*14:43")
    assert result.__class__ is Allele, f'Expected parse("B*14:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_44():
    result = parse("B*14:44")
    assert result.__class__ is Allele, f'Expected parse("B*14:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_45():
    result = parse("B*14:45")
    assert result.__class__ is Allele, f'Expected parse("B*14:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_46():
    result = parse("B*14:46")
    assert result.__class__ is Allele, f'Expected parse("B*14:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_47():
    result = parse("B*14:47")
    assert result.__class__ is Allele, f'Expected parse("B*14:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_48():
    result = parse("B*14:48")
    assert result.__class__ is Allele, f'Expected parse("B*14:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_49():
    result = parse("B*14:49")
    assert result.__class__ is Allele, f'Expected parse("B*14:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_50():
    result = parse("B*14:50")
    assert result.__class__ is Allele, f'Expected parse("B*14:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_51():
    result = parse("B*14:51")
    assert result.__class__ is Allele, f'Expected parse("B*14:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_52():
    result = parse("B*14:52")
    assert result.__class__ is Allele, f'Expected parse("B*14:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_53():
    result = parse("B*14:53")
    assert result.__class__ is Allele, f'Expected parse("B*14:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_54():
    result = parse("B*14:54")
    assert result.__class__ is Allele, f'Expected parse("B*14:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_55():
    result = parse("B*14:55")
    assert result.__class__ is Allele, f'Expected parse("B*14:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_56():
    result = parse("B*14:56")
    assert result.__class__ is Allele, f'Expected parse("B*14:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_57():
    result = parse("B*14:57")
    assert result.__class__ is Allele, f'Expected parse("B*14:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_58():
    result = parse("B*14:58")
    assert result.__class__ is Allele, f'Expected parse("B*14:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_59():
    result = parse("B*14:59")
    assert result.__class__ is Allele, f'Expected parse("B*14:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_60():
    result = parse("B*14:60")
    assert result.__class__ is Allele, f'Expected parse("B*14:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_61():
    result = parse("B*14:61")
    assert result.__class__ is Allele, f'Expected parse("B*14:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_62():
    result = parse("B*14:62")
    assert result.__class__ is Allele, f'Expected parse("B*14:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_63():
    result = parse("B*14:63")
    assert result.__class__ is Allele, f'Expected parse("B*14:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_64():
    result = parse("B*14:64")
    assert result.__class__ is Allele, f'Expected parse("B*14:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_65():
    result = parse("B*14:65")
    assert result.__class__ is Allele, f'Expected parse("B*14:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_66():
    result = parse("B*14:66")
    assert result.__class__ is Allele, f'Expected parse("B*14:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_67():
    result = parse("B*14:67")
    assert result.__class__ is Allele, f'Expected parse("B*14:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_68():
    result = parse("B*14:68")
    assert result.__class__ is Allele, f'Expected parse("B*14:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_69N():
    result = parse("B*14:69N")
    assert result.__class__ is Allele, f'Expected parse("B*14:69N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:69N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_70Q():
    result = parse("B*14:70Q")
    assert result.__class__ is Allele, f'Expected parse("B*14:70Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:70Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_71():
    result = parse("B*14:71")
    assert result.__class__ is Allele, f'Expected parse("B*14:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_72N():
    result = parse("B*14:72N")
    assert result.__class__ is Allele, f'Expected parse("B*14:72N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:72N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_73():
    result = parse("B*14:73")
    assert result.__class__ is Allele, f'Expected parse("B*14:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_74():
    result = parse("B*14:74")
    assert result.__class__ is Allele, f'Expected parse("B*14:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_75():
    result = parse("B*14:75")
    assert result.__class__ is Allele, f'Expected parse("B*14:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_76N():
    result = parse("B*14:76N")
    assert result.__class__ is Allele, f'Expected parse("B*14:76N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:76N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_77():
    result = parse("B*14:77")
    assert result.__class__ is Allele, f'Expected parse("B*14:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_78N():
    result = parse("B*14:78N")
    assert result.__class__ is Allele, f'Expected parse("B*14:78N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:78N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_79N():
    result = parse("B*14:79N")
    assert result.__class__ is Allele, f'Expected parse("B*14:79N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:79N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_80():
    result = parse("B*14:80")
    assert result.__class__ is Allele, f'Expected parse("B*14:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_81():
    result = parse("B*14:81")
    assert result.__class__ is Allele, f'Expected parse("B*14:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_82():
    result = parse("B*14:82")
    assert result.__class__ is Allele, f'Expected parse("B*14:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_83():
    result = parse("B*14:83")
    assert result.__class__ is Allele, f'Expected parse("B*14:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_84():
    result = parse("B*14:84")
    assert result.__class__ is Allele, f'Expected parse("B*14:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_85N():
    result = parse("B*14:85N")
    assert result.__class__ is Allele, f'Expected parse("B*14:85N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:85N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_86():
    result = parse("B*14:86")
    assert result.__class__ is Allele, f'Expected parse("B*14:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_87():
    result = parse("B*14:87")
    assert result.__class__ is Allele, f'Expected parse("B*14:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_88():
    result = parse("B*14:88")
    assert result.__class__ is Allele, f'Expected parse("B*14:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_89():
    result = parse("B*14:89")
    assert result.__class__ is Allele, f'Expected parse("B*14:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_14_90():
    result = parse("B*14:90")
    assert result.__class__ is Allele, f'Expected parse("B*14:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*14:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_01():
    result = parse("B*15:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_02N():
    result = parse("B*15:01:01:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:02N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_03():
    result = parse("B*15:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_04():
    result = parse("B*15:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_05():
    result = parse("B*15:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_06():
    result = parse("B*15:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_07():
    result = parse("B*15:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_08():
    result = parse("B*15:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_09():
    result = parse("B*15:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_10():
    result = parse("B*15:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_11():
    result = parse("B*15:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_12():
    result = parse("B*15:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_13():
    result = parse("B*15:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_14():
    result = parse("B*15:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_15():
    result = parse("B*15:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_16():
    result = parse("B*15:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_17():
    result = parse("B*15:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_18():
    result = parse("B*15:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_19():
    result = parse("B*15:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_20():
    result = parse("B*15:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_21():
    result = parse("B*15:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_22():
    result = parse("B*15:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_23():
    result = parse("B*15:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_24():
    result = parse("B*15:01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_25():
    result = parse("B*15:01:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_26():
    result = parse("B*15:01:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_27():
    result = parse("B*15:01:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_28():
    result = parse("B*15:01:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_29():
    result = parse("B*15:01:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_30():
    result = parse("B*15:01:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_31():
    result = parse("B*15:01:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_32():
    result = parse("B*15:01:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_33():
    result = parse("B*15:01:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_34():
    result = parse("B*15:01:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_35():
    result = parse("B*15:01:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_36():
    result = parse("B*15:01:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_37():
    result = parse("B*15:01:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_01_38():
    result = parse("B*15:01:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:01:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:01:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_02():
    result = parse("B*15:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_03():
    result = parse("B*15:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_04():
    result = parse("B*15:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_06():
    result = parse("B*15:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_07():
    result = parse("B*15:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_08():
    result = parse("B*15:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_09():
    result = parse("B*15:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_10():
    result = parse("B*15:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_11():
    result = parse("B*15:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_12():
    result = parse("B*15:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_13():
    result = parse("B*15:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_14():
    result = parse("B*15:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_15():
    result = parse("B*15:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_16():
    result = parse("B*15:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_17():
    result = parse("B*15:01:17")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_18():
    result = parse("B*15:01:18")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_19():
    result = parse("B*15:01:19")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_20():
    result = parse("B*15:01:20")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_21():
    result = parse("B*15:01:21")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_22():
    result = parse("B*15:01:22")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_23():
    result = parse("B*15:01:23")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_24():
    result = parse("B*15:01:24")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_25():
    result = parse("B*15:01:25")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_26():
    result = parse("B*15:01:26")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_27():
    result = parse("B*15:01:27")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_28():
    result = parse("B*15:01:28")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_29():
    result = parse("B*15:01:29")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_30():
    result = parse("B*15:01:30")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_31():
    result = parse("B*15:01:31")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_32():
    result = parse("B*15:01:32")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_33():
    result = parse("B*15:01:33")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_34():
    result = parse("B*15:01:34")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_35():
    result = parse("B*15:01:35")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_36():
    result = parse("B*15:01:36")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_37():
    result = parse("B*15:01:37")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_38():
    result = parse("B*15:01:38")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_39():
    result = parse("B*15:01:39")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_40():
    result = parse("B*15:01:40")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_41():
    result = parse("B*15:01:41")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_42():
    result = parse("B*15:01:42")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_43():
    result = parse("B*15:01:43")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_44():
    result = parse("B*15:01:44")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_45():
    result = parse("B*15:01:45")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_46():
    result = parse("B*15:01:46")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_47():
    result = parse("B*15:01:47")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_48():
    result = parse("B*15:01:48")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_49():
    result = parse("B*15:01:49")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_50():
    result = parse("B*15:01:50")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_51():
    result = parse("B*15:01:51")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_52():
    result = parse("B*15:01:52")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_53():
    result = parse("B*15:01:53")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_54():
    result = parse("B*15:01:54")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_55():
    result = parse("B*15:01:55")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_56():
    result = parse("B*15:01:56")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_57():
    result = parse("B*15:01:57")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_58():
    result = parse("B*15:01:58")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_59():
    result = parse("B*15:01:59")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_60():
    result = parse("B*15:01:60")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_61():
    result = parse("B*15:01:61")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_62():
    result = parse("B*15:01:62")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_01_63():
    result = parse("B*15:01:63")
    assert result.__class__ is Allele, f'Expected parse("B*15:01:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:01:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_02_01_01():
    result = parse("B*15:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_02_01_02():
    result = parse("B*15:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_02_01_03():
    result = parse("B*15:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_02_01_04():
    result = parse("B*15:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_02_02():
    result = parse("B*15:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_02_03():
    result = parse("B*15:02:03")
    assert result.__class__ is Allele, f'Expected parse("B*15:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_02_04():
    result = parse("B*15:02:04")
    assert result.__class__ is Allele, f'Expected parse("B*15:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_02_05():
    result = parse("B*15:02:05")
    assert result.__class__ is Allele, f'Expected parse("B*15:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_02_06():
    result = parse("B*15:02:06")
    assert result.__class__ is Allele, f'Expected parse("B*15:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_02_07():
    result = parse("B*15:02:07")
    assert result.__class__ is Allele, f'Expected parse("B*15:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_02_08():
    result = parse("B*15:02:08")
    assert result.__class__ is Allele, f'Expected parse("B*15:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_02_09():
    result = parse("B*15:02:09")
    assert result.__class__ is Allele, f'Expected parse("B*15:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_02_10():
    result = parse("B*15:02:10")
    assert result.__class__ is Allele, f'Expected parse("B*15:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_02_11():
    result = parse("B*15:02:11")
    assert result.__class__ is Allele, f'Expected parse("B*15:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_02_12():
    result = parse("B*15:02:12")
    assert result.__class__ is Allele, f'Expected parse("B*15:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_01_01():
    result = parse("B*15:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_01_02():
    result = parse("B*15:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_01_03():
    result = parse("B*15:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_01_04():
    result = parse("B*15:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_01_05():
    result = parse("B*15:03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:03:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_01_06():
    result = parse("B*15:03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:03:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_01_07():
    result = parse("B*15:03:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:03:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:03:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_01_08():
    result = parse("B*15:03:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:03:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:03:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_01_09():
    result = parse("B*15:03:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:03:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:03:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_02():
    result = parse("B*15:03:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_03():
    result = parse("B*15:03:03")
    assert result.__class__ is Allele, f'Expected parse("B*15:03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_04():
    result = parse("B*15:03:04")
    assert result.__class__ is Allele, f'Expected parse("B*15:03:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_05():
    result = parse("B*15:03:05")
    assert result.__class__ is Allele, f'Expected parse("B*15:03:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_06():
    result = parse("B*15:03:06")
    assert result.__class__ is Allele, f'Expected parse("B*15:03:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_07():
    result = parse("B*15:03:07")
    assert result.__class__ is Allele, f'Expected parse("B*15:03:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_08():
    result = parse("B*15:03:08")
    assert result.__class__ is Allele, f'Expected parse("B*15:03:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:03:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_09():
    result = parse("B*15:03:09")
    assert result.__class__ is Allele, f'Expected parse("B*15:03:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:03:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_10():
    result = parse("B*15:03:10")
    assert result.__class__ is Allele, f'Expected parse("B*15:03:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:03:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_03_11():
    result = parse("B*15:03:11")
    assert result.__class__ is Allele, f'Expected parse("B*15:03:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:03:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_04_01_01():
    result = parse("B*15:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_04_01_02():
    result = parse("B*15:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_04_01_03():
    result = parse("B*15:04:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:04:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:04:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_04_02():
    result = parse("B*15:04:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_04_03():
    result = parse("B*15:04:03")
    assert result.__class__ is Allele, f'Expected parse("B*15:04:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_04_04():
    result = parse("B*15:04:04")
    assert result.__class__ is Allele, f'Expected parse("B*15:04:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:04:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_05_01():
    result = parse("B*15:05:01")
    assert result.__class__ is Allele, f'Expected parse("B*15:05:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_05_02():
    result = parse("B*15:05:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:05:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_05_03():
    result = parse("B*15:05:03")
    assert result.__class__ is Allele, f'Expected parse("B*15:05:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:05:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_06():
    result = parse("B*15:06")
    assert result.__class__ is Allele, f'Expected parse("B*15:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_07_01_01():
    result = parse("B*15:07:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:07:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:07:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_07_01_02():
    result = parse("B*15:07:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:07:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:07:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_07_01_03():
    result = parse("B*15:07:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:07:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:07:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_07_01_04():
    result = parse("B*15:07:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:07:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:07:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_07_01_05():
    result = parse("B*15:07:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:07:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:07:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_07_02():
    result = parse("B*15:07:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:07:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_07_03():
    result = parse("B*15:07:03")
    assert result.__class__ is Allele, f'Expected parse("B*15:07:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:07:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_08_01():
    result = parse("B*15:08:01")
    assert result.__class__ is Allele, f'Expected parse("B*15:08:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:08:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_08_02():
    result = parse("B*15:08:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:08:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:08:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_09_01():
    result = parse("B*15:09:01")
    assert result.__class__ is Allele, f'Expected parse("B*15:09:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:09:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_09_02():
    result = parse("B*15:09:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:09:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:09:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_101():
    result = parse("B*15:101")
    assert result.__class__ is Allele, f'Expected parse("B*15:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_102():
    result = parse("B*15:102")
    assert result.__class__ is Allele, f'Expected parse("B*15:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_103():
    result = parse("B*15:103")
    assert result.__class__ is Allele, f'Expected parse("B*15:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_104():
    result = parse("B*15:104")
    assert result.__class__ is Allele, f'Expected parse("B*15:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_105():
    result = parse("B*15:105")
    assert result.__class__ is Allele, f'Expected parse("B*15:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_106():
    result = parse("B*15:106")
    assert result.__class__ is Allele, f'Expected parse("B*15:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_107():
    result = parse("B*15:107")
    assert result.__class__ is Allele, f'Expected parse("B*15:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_108():
    result = parse("B*15:108")
    assert result.__class__ is Allele, f'Expected parse("B*15:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_109():
    result = parse("B*15:109")
    assert result.__class__ is Allele, f'Expected parse("B*15:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_10_01_01():
    result = parse("B*15:10:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:10:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:10:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_10_01_02():
    result = parse("B*15:10:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:10:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:10:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_10_01_03():
    result = parse("B*15:10:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:10:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:10:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_10_01_04():
    result = parse("B*15:10:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:10:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:10:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_10_01_05():
    result = parse("B*15:10:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:10:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:10:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_10_01_06():
    result = parse("B*15:10:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:10:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:10:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_10_02():
    result = parse("B*15:10:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:10:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:10:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_10_03():
    result = parse("B*15:10:03")
    assert result.__class__ is Allele, f'Expected parse("B*15:10:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:10:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_10_04():
    result = parse("B*15:10:04")
    assert result.__class__ is Allele, f'Expected parse("B*15:10:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:10:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_10_05():
    result = parse("B*15:10:05")
    assert result.__class__ is Allele, f'Expected parse("B*15:10:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:10:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_110():
    result = parse("B*15:110")
    assert result.__class__ is Allele, f'Expected parse("B*15:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_111N():
    result = parse("B*15:111N")
    assert result.__class__ is Allele, f'Expected parse("B*15:111N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:111N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_112():
    result = parse("B*15:112")
    assert result.__class__ is Allele, f'Expected parse("B*15:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_113():
    result = parse("B*15:113")
    assert result.__class__ is Allele, f'Expected parse("B*15:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_114():
    result = parse("B*15:114")
    assert result.__class__ is Allele, f'Expected parse("B*15:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_115():
    result = parse("B*15:115")
    assert result.__class__ is Allele, f'Expected parse("B*15:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_116():
    result = parse("B*15:116")
    assert result.__class__ is Allele, f'Expected parse("B*15:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_117():
    result = parse("B*15:117")
    assert result.__class__ is Allele, f'Expected parse("B*15:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_118():
    result = parse("B*15:118")
    assert result.__class__ is Allele, f'Expected parse("B*15:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_119():
    result = parse("B*15:119")
    assert result.__class__ is Allele, f'Expected parse("B*15:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_11_01():
    result = parse("B*15:11:01")
    assert result.__class__ is Allele, f'Expected parse("B*15:11:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:11:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_11_02():
    result = parse("B*15:11:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:11:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:11:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_11_03():
    result = parse("B*15:11:03")
    assert result.__class__ is Allele, f'Expected parse("B*15:11:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:11:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_11_04():
    result = parse("B*15:11:04")
    assert result.__class__ is Allele, f'Expected parse("B*15:11:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:11:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_11_05():
    result = parse("B*15:11:05")
    assert result.__class__ is Allele, f'Expected parse("B*15:11:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:11:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_11_06():
    result = parse("B*15:11:06")
    assert result.__class__ is Allele, f'Expected parse("B*15:11:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:11:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_11_07():
    result = parse("B*15:11:07")
    assert result.__class__ is Allele, f'Expected parse("B*15:11:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:11:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_120():
    result = parse("B*15:120")
    assert result.__class__ is Allele, f'Expected parse("B*15:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_121():
    result = parse("B*15:121")
    assert result.__class__ is Allele, f'Expected parse("B*15:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_122():
    result = parse("B*15:122")
    assert result.__class__ is Allele, f'Expected parse("B*15:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_123():
    result = parse("B*15:123")
    assert result.__class__ is Allele, f'Expected parse("B*15:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_124():
    result = parse("B*15:124")
    assert result.__class__ is Allele, f'Expected parse("B*15:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_125_01():
    result = parse("B*15:125:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:125:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:125:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_125_02():
    result = parse("B*15:125:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:125:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:125:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_126():
    result = parse("B*15:126")
    assert result.__class__ is Allele, f'Expected parse("B*15:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_127():
    result = parse("B*15:127")
    assert result.__class__ is Allele, f'Expected parse("B*15:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_128():
    result = parse("B*15:128")
    assert result.__class__ is Allele, f'Expected parse("B*15:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_129():
    result = parse("B*15:129")
    assert result.__class__ is Allele, f'Expected parse("B*15:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_12_01():
    result = parse("B*15:12:01")
    assert result.__class__ is Allele, f'Expected parse("B*15:12:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:12:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_12_02():
    result = parse("B*15:12:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:12:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:12:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_12_03():
    result = parse("B*15:12:03")
    assert result.__class__ is Allele, f'Expected parse("B*15:12:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:12:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_131():
    result = parse("B*15:131")
    assert result.__class__ is Allele, f'Expected parse("B*15:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_132():
    result = parse("B*15:132")
    assert result.__class__ is Allele, f'Expected parse("B*15:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_133():
    result = parse("B*15:133")
    assert result.__class__ is Allele, f'Expected parse("B*15:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_134():
    result = parse("B*15:134")
    assert result.__class__ is Allele, f'Expected parse("B*15:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_135():
    result = parse("B*15:135")
    assert result.__class__ is Allele, f'Expected parse("B*15:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_136():
    result = parse("B*15:136")
    assert result.__class__ is Allele, f'Expected parse("B*15:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_137():
    result = parse("B*15:137")
    assert result.__class__ is Allele, f'Expected parse("B*15:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_138():
    result = parse("B*15:138")
    assert result.__class__ is Allele, f'Expected parse("B*15:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_139():
    result = parse("B*15:139")
    assert result.__class__ is Allele, f'Expected parse("B*15:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_13_01():
    result = parse("B*15:13:01")
    assert result.__class__ is Allele, f'Expected parse("B*15:13:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:13:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_13_02():
    result = parse("B*15:13:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:13:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:13:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_14():
    result = parse("B*15:14")
    assert result.__class__ is Allele, f'Expected parse("B*15:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_140():
    result = parse("B*15:140")
    assert result.__class__ is Allele, f'Expected parse("B*15:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_141():
    result = parse("B*15:141")
    assert result.__class__ is Allele, f'Expected parse("B*15:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_142():
    result = parse("B*15:142")
    assert result.__class__ is Allele, f'Expected parse("B*15:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_143():
    result = parse("B*15:143")
    assert result.__class__ is Allele, f'Expected parse("B*15:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_144():
    result = parse("B*15:144")
    assert result.__class__ is Allele, f'Expected parse("B*15:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_145():
    result = parse("B*15:145")
    assert result.__class__ is Allele, f'Expected parse("B*15:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_146():
    result = parse("B*15:146")
    assert result.__class__ is Allele, f'Expected parse("B*15:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_147():
    result = parse("B*15:147")
    assert result.__class__ is Allele, f'Expected parse("B*15:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_148():
    result = parse("B*15:148")
    assert result.__class__ is Allele, f'Expected parse("B*15:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_149N():
    result = parse("B*15:149N")
    assert result.__class__ is Allele, f'Expected parse("B*15:149N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:149N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_150():
    result = parse("B*15:150")
    assert result.__class__ is Allele, f'Expected parse("B*15:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_151():
    result = parse("B*15:151")
    assert result.__class__ is Allele, f'Expected parse("B*15:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_152():
    result = parse("B*15:152")
    assert result.__class__ is Allele, f'Expected parse("B*15:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_153():
    result = parse("B*15:153")
    assert result.__class__ is Allele, f'Expected parse("B*15:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_154():
    result = parse("B*15:154")
    assert result.__class__ is Allele, f'Expected parse("B*15:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_155():
    result = parse("B*15:155")
    assert result.__class__ is Allele, f'Expected parse("B*15:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_156():
    result = parse("B*15:156")
    assert result.__class__ is Allele, f'Expected parse("B*15:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_157():
    result = parse("B*15:157")
    assert result.__class__ is Allele, f'Expected parse("B*15:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_158():
    result = parse("B*15:158")
    assert result.__class__ is Allele, f'Expected parse("B*15:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_159():
    result = parse("B*15:159")
    assert result.__class__ is Allele, f'Expected parse("B*15:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_15_01_01():
    result = parse("B*15:15:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:15:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:15:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_15_01_02():
    result = parse("B*15:15:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:15:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:15:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_160_01_01():
    result = parse("B*15:160:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:160:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:160:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_160_01_02():
    result = parse("B*15:160:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:160:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:160:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_161():
    result = parse("B*15:161")
    assert result.__class__ is Allele, f'Expected parse("B*15:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_162():
    result = parse("B*15:162")
    assert result.__class__ is Allele, f'Expected parse("B*15:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_163():
    result = parse("B*15:163")
    assert result.__class__ is Allele, f'Expected parse("B*15:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_164():
    result = parse("B*15:164")
    assert result.__class__ is Allele, f'Expected parse("B*15:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_165():
    result = parse("B*15:165")
    assert result.__class__ is Allele, f'Expected parse("B*15:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_166():
    result = parse("B*15:166")
    assert result.__class__ is Allele, f'Expected parse("B*15:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_167():
    result = parse("B*15:167")
    assert result.__class__ is Allele, f'Expected parse("B*15:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_168():
    result = parse("B*15:168")
    assert result.__class__ is Allele, f'Expected parse("B*15:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_169():
    result = parse("B*15:169")
    assert result.__class__ is Allele, f'Expected parse("B*15:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_16_01_01():
    result = parse("B*15:16:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:16:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:16:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_16_01_02():
    result = parse("B*15:16:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:16:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:16:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_16_01_03():
    result = parse("B*15:16:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:16:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:16:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_16_01_04():
    result = parse("B*15:16:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:16:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:16:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_16_01_05():
    result = parse("B*15:16:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:16:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:16:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_16_01_06():
    result = parse("B*15:16:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:16:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:16:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_16_01_07():
    result = parse("B*15:16:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:16:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:16:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_16_02_01():
    result = parse("B*15:16:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:16:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:16:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_16_02_02():
    result = parse("B*15:16:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:16:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:16:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_16_03():
    result = parse("B*15:16:03")
    assert result.__class__ is Allele, f'Expected parse("B*15:16:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:16:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_16_04():
    result = parse("B*15:16:04")
    assert result.__class__ is Allele, f'Expected parse("B*15:16:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:16:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_170():
    result = parse("B*15:170")
    assert result.__class__ is Allele, f'Expected parse("B*15:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_171():
    result = parse("B*15:171")
    assert result.__class__ is Allele, f'Expected parse("B*15:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_172():
    result = parse("B*15:172")
    assert result.__class__ is Allele, f'Expected parse("B*15:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_173():
    result = parse("B*15:173")
    assert result.__class__ is Allele, f'Expected parse("B*15:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_174():
    result = parse("B*15:174")
    assert result.__class__ is Allele, f'Expected parse("B*15:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_175():
    result = parse("B*15:175")
    assert result.__class__ is Allele, f'Expected parse("B*15:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_176():
    result = parse("B*15:176")
    assert result.__class__ is Allele, f'Expected parse("B*15:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_177():
    result = parse("B*15:177")
    assert result.__class__ is Allele, f'Expected parse("B*15:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_178():
    result = parse("B*15:178")
    assert result.__class__ is Allele, f'Expected parse("B*15:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_179_01():
    result = parse("B*15:179:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:179:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:179:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_179_02():
    result = parse("B*15:179:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:179:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:179:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_17_01_01():
    result = parse("B*15:17:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:17:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:17:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_17_01_02():
    result = parse("B*15:17:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:17:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:17:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_17_01_03():
    result = parse("B*15:17:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:17:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:17:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_17_02():
    result = parse("B*15:17:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:17:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:17:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_17_03():
    result = parse("B*15:17:03")
    assert result.__class__ is Allele, f'Expected parse("B*15:17:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:17:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_17_04():
    result = parse("B*15:17:04")
    assert result.__class__ is Allele, f'Expected parse("B*15:17:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:17:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_17_05():
    result = parse("B*15:17:05")
    assert result.__class__ is Allele, f'Expected parse("B*15:17:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:17:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_17_06():
    result = parse("B*15:17:06")
    assert result.__class__ is Allele, f'Expected parse("B*15:17:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:17:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_17_07():
    result = parse("B*15:17:07")
    assert result.__class__ is Allele, f'Expected parse("B*15:17:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:17:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_180():
    result = parse("B*15:180")
    assert result.__class__ is Allele, f'Expected parse("B*15:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_181N():
    result = parse("B*15:181N")
    assert result.__class__ is Allele, f'Expected parse("B*15:181N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:181N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_182N():
    result = parse("B*15:182N")
    assert result.__class__ is Allele, f'Expected parse("B*15:182N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:182N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_183():
    result = parse("B*15:183")
    assert result.__class__ is Allele, f'Expected parse("B*15:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_184():
    result = parse("B*15:184")
    assert result.__class__ is Allele, f'Expected parse("B*15:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_185():
    result = parse("B*15:185")
    assert result.__class__ is Allele, f'Expected parse("B*15:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_186():
    result = parse("B*15:186")
    assert result.__class__ is Allele, f'Expected parse("B*15:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_187():
    result = parse("B*15:187")
    assert result.__class__ is Allele, f'Expected parse("B*15:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_188():
    result = parse("B*15:188")
    assert result.__class__ is Allele, f'Expected parse("B*15:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_189():
    result = parse("B*15:189")
    assert result.__class__ is Allele, f'Expected parse("B*15:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_18_01_01():
    result = parse("B*15:18:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:18:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:18:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_18_01_02():
    result = parse("B*15:18:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:18:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:18:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_18_01_03():
    result = parse("B*15:18:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:18:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:18:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_18_01_04():
    result = parse("B*15:18:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:18:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:18:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_18_01_05():
    result = parse("B*15:18:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:18:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:18:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_18_01_06():
    result = parse("B*15:18:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:18:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:18:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_18_01_07():
    result = parse("B*15:18:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:18:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:18:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_18_01_08():
    result = parse("B*15:18:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:18:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:18:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_18_02():
    result = parse("B*15:18:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:18:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:18:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_18_03():
    result = parse("B*15:18:03")
    assert result.__class__ is Allele, f'Expected parse("B*15:18:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:18:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_18_04():
    result = parse("B*15:18:04")
    assert result.__class__ is Allele, f'Expected parse("B*15:18:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:18:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_18_05():
    result = parse("B*15:18:05")
    assert result.__class__ is Allele, f'Expected parse("B*15:18:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:18:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_18_06():
    result = parse("B*15:18:06")
    assert result.__class__ is Allele, f'Expected parse("B*15:18:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:18:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_18_07():
    result = parse("B*15:18:07")
    assert result.__class__ is Allele, f'Expected parse("B*15:18:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:18:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_18_08():
    result = parse("B*15:18:08")
    assert result.__class__ is Allele, f'Expected parse("B*15:18:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:18:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_18_09():
    result = parse("B*15:18:09")
    assert result.__class__ is Allele, f'Expected parse("B*15:18:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:18:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_19():
    result = parse("B*15:19")
    assert result.__class__ is Allele, f'Expected parse("B*15:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_190N():
    result = parse("B*15:190N")
    assert result.__class__ is Allele, f'Expected parse("B*15:190N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:190N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_191():
    result = parse("B*15:191")
    assert result.__class__ is Allele, f'Expected parse("B*15:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_192():
    result = parse("B*15:192")
    assert result.__class__ is Allele, f'Expected parse("B*15:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_193():
    result = parse("B*15:193")
    assert result.__class__ is Allele, f'Expected parse("B*15:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_194():
    result = parse("B*15:194")
    assert result.__class__ is Allele, f'Expected parse("B*15:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_195():
    result = parse("B*15:195")
    assert result.__class__ is Allele, f'Expected parse("B*15:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_196():
    result = parse("B*15:196")
    assert result.__class__ is Allele, f'Expected parse("B*15:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_197_01():
    result = parse("B*15:197:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:197:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:197:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_197_02():
    result = parse("B*15:197:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:197:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:197:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_198():
    result = parse("B*15:198")
    assert result.__class__ is Allele, f'Expected parse("B*15:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_199():
    result = parse("B*15:199")
    assert result.__class__ is Allele, f'Expected parse("B*15:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_20():
    result = parse("B*15:20")
    assert result.__class__ is Allele, f'Expected parse("B*15:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_200():
    result = parse("B*15:200")
    assert result.__class__ is Allele, f'Expected parse("B*15:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_201():
    result = parse("B*15:201")
    assert result.__class__ is Allele, f'Expected parse("B*15:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_202():
    result = parse("B*15:202")
    assert result.__class__ is Allele, f'Expected parse("B*15:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_203():
    result = parse("B*15:203")
    assert result.__class__ is Allele, f'Expected parse("B*15:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_204():
    result = parse("B*15:204")
    assert result.__class__ is Allele, f'Expected parse("B*15:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_205():
    result = parse("B*15:205")
    assert result.__class__ is Allele, f'Expected parse("B*15:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_206():
    result = parse("B*15:206")
    assert result.__class__ is Allele, f'Expected parse("B*15:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_207():
    result = parse("B*15:207")
    assert result.__class__ is Allele, f'Expected parse("B*15:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_208():
    result = parse("B*15:208")
    assert result.__class__ is Allele, f'Expected parse("B*15:208") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_209N():
    result = parse("B*15:209N")
    assert result.__class__ is Allele, f'Expected parse("B*15:209N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:209N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_210():
    result = parse("B*15:210")
    assert result.__class__ is Allele, f'Expected parse("B*15:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_211():
    result = parse("B*15:211")
    assert result.__class__ is Allele, f'Expected parse("B*15:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_212():
    result = parse("B*15:212")
    assert result.__class__ is Allele, f'Expected parse("B*15:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_213():
    result = parse("B*15:213")
    assert result.__class__ is Allele, f'Expected parse("B*15:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_214():
    result = parse("B*15:214")
    assert result.__class__ is Allele, f'Expected parse("B*15:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_215():
    result = parse("B*15:215")
    assert result.__class__ is Allele, f'Expected parse("B*15:215") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_216():
    result = parse("B*15:216")
    assert result.__class__ is Allele, f'Expected parse("B*15:216") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_217():
    result = parse("B*15:217")
    assert result.__class__ is Allele, f'Expected parse("B*15:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_218Q():
    result = parse("B*15:218Q")
    assert result.__class__ is Allele, f'Expected parse("B*15:218Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:218Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_219():
    result = parse("B*15:219")
    assert result.__class__ is Allele, f'Expected parse("B*15:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_21_01_01():
    result = parse("B*15:21:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:21:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:21:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_21_01_02():
    result = parse("B*15:21:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:21:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:21:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_220_01_01():
    result = parse("B*15:220:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:220:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:220:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_220_01_02():
    result = parse("B*15:220:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:220:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:220:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_220_02():
    result = parse("B*15:220:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:220:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:220:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_221():
    result = parse("B*15:221")
    assert result.__class__ is Allele, f'Expected parse("B*15:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_222():
    result = parse("B*15:222")
    assert result.__class__ is Allele, f'Expected parse("B*15:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_223():
    result = parse("B*15:223")
    assert result.__class__ is Allele, f'Expected parse("B*15:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_224():
    result = parse("B*15:224")
    assert result.__class__ is Allele, f'Expected parse("B*15:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_225():
    result = parse("B*15:225")
    assert result.__class__ is Allele, f'Expected parse("B*15:225") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_226N():
    result = parse("B*15:226N")
    assert result.__class__ is Allele, f'Expected parse("B*15:226N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:226N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_227():
    result = parse("B*15:227")
    assert result.__class__ is Allele, f'Expected parse("B*15:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_228():
    result = parse("B*15:228")
    assert result.__class__ is Allele, f'Expected parse("B*15:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_229():
    result = parse("B*15:229")
    assert result.__class__ is Allele, f'Expected parse("B*15:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_23():
    result = parse("B*15:23")
    assert result.__class__ is Allele, f'Expected parse("B*15:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_230():
    result = parse("B*15:230")
    assert result.__class__ is Allele, f'Expected parse("B*15:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_231():
    result = parse("B*15:231")
    assert result.__class__ is Allele, f'Expected parse("B*15:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_232():
    result = parse("B*15:232")
    assert result.__class__ is Allele, f'Expected parse("B*15:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_233():
    result = parse("B*15:233")
    assert result.__class__ is Allele, f'Expected parse("B*15:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_234():
    result = parse("B*15:234")
    assert result.__class__ is Allele, f'Expected parse("B*15:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_235():
    result = parse("B*15:235")
    assert result.__class__ is Allele, f'Expected parse("B*15:235") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_236():
    result = parse("B*15:236")
    assert result.__class__ is Allele, f'Expected parse("B*15:236") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_237():
    result = parse("B*15:237")
    assert result.__class__ is Allele, f'Expected parse("B*15:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_238():
    result = parse("B*15:238")
    assert result.__class__ is Allele, f'Expected parse("B*15:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_239():
    result = parse("B*15:239")
    assert result.__class__ is Allele, f'Expected parse("B*15:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_240():
    result = parse("B*15:240")
    assert result.__class__ is Allele, f'Expected parse("B*15:240") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_241():
    result = parse("B*15:241")
    assert result.__class__ is Allele, f'Expected parse("B*15:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_242_01():
    result = parse("B*15:242:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:242:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:242:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_242_02():
    result = parse("B*15:242:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:242:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:242:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_243():
    result = parse("B*15:243")
    assert result.__class__ is Allele, f'Expected parse("B*15:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_244():
    result = parse("B*15:244")
    assert result.__class__ is Allele, f'Expected parse("B*15:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_245_01Q():
    result = parse("B*15:245:01Q")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:245:01Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:245:01Q") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_245_02Q():
    result = parse("B*15:245:02Q")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:245:02Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:245:02Q") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_246N():
    result = parse("B*15:246N")
    assert result.__class__ is Allele, f'Expected parse("B*15:246N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:246N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_247():
    result = parse("B*15:247")
    assert result.__class__ is Allele, f'Expected parse("B*15:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_248():
    result = parse("B*15:248")
    assert result.__class__ is Allele, f'Expected parse("B*15:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_249():
    result = parse("B*15:249")
    assert result.__class__ is Allele, f'Expected parse("B*15:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_24_01():
    result = parse("B*15:24:01")
    assert result.__class__ is Allele, f'Expected parse("B*15:24:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:24:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_24_02():
    result = parse("B*15:24:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:24:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:24:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_250():
    result = parse("B*15:250")
    assert result.__class__ is Allele, f'Expected parse("B*15:250") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_251_01():
    result = parse("B*15:251:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:251:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:251:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_251_02():
    result = parse("B*15:251:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:251:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:251:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_251_03():
    result = parse("B*15:251:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:251:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:251:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_252():
    result = parse("B*15:252")
    assert result.__class__ is Allele, f'Expected parse("B*15:252") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_253():
    result = parse("B*15:253")
    assert result.__class__ is Allele, f'Expected parse("B*15:253") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_254():
    result = parse("B*15:254")
    assert result.__class__ is Allele, f'Expected parse("B*15:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_255():
    result = parse("B*15:255")
    assert result.__class__ is Allele, f'Expected parse("B*15:255") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_256():
    result = parse("B*15:256")
    assert result.__class__ is Allele, f'Expected parse("B*15:256") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_257():
    result = parse("B*15:257")
    assert result.__class__ is Allele, f'Expected parse("B*15:257") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_258N():
    result = parse("B*15:258N")
    assert result.__class__ is Allele, f'Expected parse("B*15:258N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:258N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_259():
    result = parse("B*15:259")
    assert result.__class__ is Allele, f'Expected parse("B*15:259") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_25_01_01():
    result = parse("B*15:25:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:25:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:25:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_25_01_02():
    result = parse("B*15:25:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:25:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:25:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_25_02():
    result = parse("B*15:25:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:25:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:25:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_25_03():
    result = parse("B*15:25:03")
    assert result.__class__ is Allele, f'Expected parse("B*15:25:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:25:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_25_04():
    result = parse("B*15:25:04")
    assert result.__class__ is Allele, f'Expected parse("B*15:25:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:25:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_260():
    result = parse("B*15:260")
    assert result.__class__ is Allele, f'Expected parse("B*15:260") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_261():
    result = parse("B*15:261")
    assert result.__class__ is Allele, f'Expected parse("B*15:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_262N():
    result = parse("B*15:262N")
    assert result.__class__ is Allele, f'Expected parse("B*15:262N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:262N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_263():
    result = parse("B*15:263")
    assert result.__class__ is Allele, f'Expected parse("B*15:263") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_264():
    result = parse("B*15:264")
    assert result.__class__ is Allele, f'Expected parse("B*15:264") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_265():
    result = parse("B*15:265")
    assert result.__class__ is Allele, f'Expected parse("B*15:265") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_266():
    result = parse("B*15:266")
    assert result.__class__ is Allele, f'Expected parse("B*15:266") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_267():
    result = parse("B*15:267")
    assert result.__class__ is Allele, f'Expected parse("B*15:267") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_268():
    result = parse("B*15:268")
    assert result.__class__ is Allele, f'Expected parse("B*15:268") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_269():
    result = parse("B*15:269")
    assert result.__class__ is Allele, f'Expected parse("B*15:269") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_26N():
    result = parse("B*15:26N")
    assert result.__class__ is Allele, f'Expected parse("B*15:26N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:26N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_270():
    result = parse("B*15:270")
    assert result.__class__ is Allele, f'Expected parse("B*15:270") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_271():
    result = parse("B*15:271")
    assert result.__class__ is Allele, f'Expected parse("B*15:271") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_272N():
    result = parse("B*15:272N")
    assert result.__class__ is Allele, f'Expected parse("B*15:272N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:272N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_273():
    result = parse("B*15:273")
    assert result.__class__ is Allele, f'Expected parse("B*15:273") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_274():
    result = parse("B*15:274")
    assert result.__class__ is Allele, f'Expected parse("B*15:274") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_275_01():
    result = parse("B*15:275:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:275:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:275:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_275_02():
    result = parse("B*15:275:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:275:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:275:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_276():
    result = parse("B*15:276")
    assert result.__class__ is Allele, f'Expected parse("B*15:276") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_277():
    result = parse("B*15:277")
    assert result.__class__ is Allele, f'Expected parse("B*15:277") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_278():
    result = parse("B*15:278")
    assert result.__class__ is Allele, f'Expected parse("B*15:278") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_279():
    result = parse("B*15:279")
    assert result.__class__ is Allele, f'Expected parse("B*15:279") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_27_01():
    result = parse("B*15:27:01")
    assert result.__class__ is Allele, f'Expected parse("B*15:27:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:27:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_27_02():
    result = parse("B*15:27:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:27:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:27:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_27_03():
    result = parse("B*15:27:03")
    assert result.__class__ is Allele, f'Expected parse("B*15:27:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:27:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_27_04():
    result = parse("B*15:27:04")
    assert result.__class__ is Allele, f'Expected parse("B*15:27:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:27:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_28():
    result = parse("B*15:28")
    assert result.__class__ is Allele, f'Expected parse("B*15:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_280():
    result = parse("B*15:280")
    assert result.__class__ is Allele, f'Expected parse("B*15:280") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_281():
    result = parse("B*15:281")
    assert result.__class__ is Allele, f'Expected parse("B*15:281") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_282():
    result = parse("B*15:282")
    assert result.__class__ is Allele, f'Expected parse("B*15:282") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_283():
    result = parse("B*15:283")
    assert result.__class__ is Allele, f'Expected parse("B*15:283") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_284():
    result = parse("B*15:284")
    assert result.__class__ is Allele, f'Expected parse("B*15:284") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_285():
    result = parse("B*15:285")
    assert result.__class__ is Allele, f'Expected parse("B*15:285") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_286():
    result = parse("B*15:286")
    assert result.__class__ is Allele, f'Expected parse("B*15:286") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_287():
    result = parse("B*15:287")
    assert result.__class__ is Allele, f'Expected parse("B*15:287") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:287") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_288():
    result = parse("B*15:288")
    assert result.__class__ is Allele, f'Expected parse("B*15:288") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_289():
    result = parse("B*15:289")
    assert result.__class__ is Allele, f'Expected parse("B*15:289") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_290():
    result = parse("B*15:290")
    assert result.__class__ is Allele, f'Expected parse("B*15:290") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_291():
    result = parse("B*15:291")
    assert result.__class__ is Allele, f'Expected parse("B*15:291") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_292():
    result = parse("B*15:292")
    assert result.__class__ is Allele, f'Expected parse("B*15:292") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_293():
    result = parse("B*15:293")
    assert result.__class__ is Allele, f'Expected parse("B*15:293") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_294N():
    result = parse("B*15:294N")
    assert result.__class__ is Allele, f'Expected parse("B*15:294N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:294N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_295():
    result = parse("B*15:295")
    assert result.__class__ is Allele, f'Expected parse("B*15:295") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_296():
    result = parse("B*15:296")
    assert result.__class__ is Allele, f'Expected parse("B*15:296") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_297():
    result = parse("B*15:297")
    assert result.__class__ is Allele, f'Expected parse("B*15:297") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_298():
    result = parse("B*15:298")
    assert result.__class__ is Allele, f'Expected parse("B*15:298") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_299():
    result = parse("B*15:299")
    assert result.__class__ is Allele, f'Expected parse("B*15:299") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_29_01_01():
    result = parse("B*15:29:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:29:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:29:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_29_01_02():
    result = parse("B*15:29:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:29:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:29:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_300():
    result = parse("B*15:300")
    assert result.__class__ is Allele, f'Expected parse("B*15:300") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_301():
    result = parse("B*15:301")
    assert result.__class__ is Allele, f'Expected parse("B*15:301") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_302N():
    result = parse("B*15:302N")
    assert result.__class__ is Allele, f'Expected parse("B*15:302N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:302N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_303():
    result = parse("B*15:303")
    assert result.__class__ is Allele, f'Expected parse("B*15:303") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:303") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_304N():
    result = parse("B*15:304N")
    assert result.__class__ is Allele, f'Expected parse("B*15:304N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:304N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_305():
    result = parse("B*15:305")
    assert result.__class__ is Allele, f'Expected parse("B*15:305") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_306():
    result = parse("B*15:306")
    assert result.__class__ is Allele, f'Expected parse("B*15:306") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:306") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_307():
    result = parse("B*15:307")
    assert result.__class__ is Allele, f'Expected parse("B*15:307") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_308():
    result = parse("B*15:308")
    assert result.__class__ is Allele, f'Expected parse("B*15:308") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:308") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_309():
    result = parse("B*15:309")
    assert result.__class__ is Allele, f'Expected parse("B*15:309") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:309") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_30_01_01():
    result = parse("B*15:30:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:30:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:30:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_30_01_02():
    result = parse("B*15:30:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:30:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:30:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_30_01_03():
    result = parse("B*15:30:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:30:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:30:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_310():
    result = parse("B*15:310")
    assert result.__class__ is Allele, f'Expected parse("B*15:310") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:310") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_311():
    result = parse("B*15:311")
    assert result.__class__ is Allele, f'Expected parse("B*15:311") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:311") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_312():
    result = parse("B*15:312")
    assert result.__class__ is Allele, f'Expected parse("B*15:312") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:312") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_313():
    result = parse("B*15:313")
    assert result.__class__ is Allele, f'Expected parse("B*15:313") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:313") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_314():
    result = parse("B*15:314")
    assert result.__class__ is Allele, f'Expected parse("B*15:314") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:314") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_315():
    result = parse("B*15:315")
    assert result.__class__ is Allele, f'Expected parse("B*15:315") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:315") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_316():
    result = parse("B*15:316")
    assert result.__class__ is Allele, f'Expected parse("B*15:316") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:316") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_317():
    result = parse("B*15:317")
    assert result.__class__ is Allele, f'Expected parse("B*15:317") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:317") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_318():
    result = parse("B*15:318")
    assert result.__class__ is Allele, f'Expected parse("B*15:318") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:318") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_319():
    result = parse("B*15:319")
    assert result.__class__ is Allele, f'Expected parse("B*15:319") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_31_01_01():
    result = parse("B*15:31:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:31:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:31:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_31_01_02():
    result = parse("B*15:31:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:31:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:31:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_31_01_03():
    result = parse("B*15:31:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:31:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:31:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_320():
    result = parse("B*15:320")
    assert result.__class__ is Allele, f'Expected parse("B*15:320") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:320") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_321Q():
    result = parse("B*15:321Q")
    assert result.__class__ is Allele, f'Expected parse("B*15:321Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:321Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_322():
    result = parse("B*15:322")
    assert result.__class__ is Allele, f'Expected parse("B*15:322") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:322") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_323():
    result = parse("B*15:323")
    assert result.__class__ is Allele, f'Expected parse("B*15:323") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:323") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_324():
    result = parse("B*15:324")
    assert result.__class__ is Allele, f'Expected parse("B*15:324") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:324") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_325():
    result = parse("B*15:325")
    assert result.__class__ is Allele, f'Expected parse("B*15:325") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:325") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_326():
    result = parse("B*15:326")
    assert result.__class__ is Allele, f'Expected parse("B*15:326") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:326") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_327():
    result = parse("B*15:327")
    assert result.__class__ is Allele, f'Expected parse("B*15:327") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:327") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_328():
    result = parse("B*15:328")
    assert result.__class__ is Allele, f'Expected parse("B*15:328") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:328") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_329():
    result = parse("B*15:329")
    assert result.__class__ is Allele, f'Expected parse("B*15:329") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:329") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_32_01():
    result = parse("B*15:32:01")
    assert result.__class__ is Allele, f'Expected parse("B*15:32:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:32:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_32_02():
    result = parse("B*15:32:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:32:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:32:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_33():
    result = parse("B*15:33")
    assert result.__class__ is Allele, f'Expected parse("B*15:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_330():
    result = parse("B*15:330")
    assert result.__class__ is Allele, f'Expected parse("B*15:330") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:330") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_331():
    result = parse("B*15:331")
    assert result.__class__ is Allele, f'Expected parse("B*15:331") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:331") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_332():
    result = parse("B*15:332")
    assert result.__class__ is Allele, f'Expected parse("B*15:332") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:332") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_333():
    result = parse("B*15:333")
    assert result.__class__ is Allele, f'Expected parse("B*15:333") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:333") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_334():
    result = parse("B*15:334")
    assert result.__class__ is Allele, f'Expected parse("B*15:334") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:334") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_335():
    result = parse("B*15:335")
    assert result.__class__ is Allele, f'Expected parse("B*15:335") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:335") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_336():
    result = parse("B*15:336")
    assert result.__class__ is Allele, f'Expected parse("B*15:336") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:336") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_337():
    result = parse("B*15:337")
    assert result.__class__ is Allele, f'Expected parse("B*15:337") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:337") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_338():
    result = parse("B*15:338")
    assert result.__class__ is Allele, f'Expected parse("B*15:338") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:338") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_339():
    result = parse("B*15:339")
    assert result.__class__ is Allele, f'Expected parse("B*15:339") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:339") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_340():
    result = parse("B*15:340")
    assert result.__class__ is Allele, f'Expected parse("B*15:340") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:340") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_341():
    result = parse("B*15:341")
    assert result.__class__ is Allele, f'Expected parse("B*15:341") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:341") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_342():
    result = parse("B*15:342")
    assert result.__class__ is Allele, f'Expected parse("B*15:342") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:342") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_343():
    result = parse("B*15:343")
    assert result.__class__ is Allele, f'Expected parse("B*15:343") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:343") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_344():
    result = parse("B*15:344")
    assert result.__class__ is Allele, f'Expected parse("B*15:344") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:344") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_345():
    result = parse("B*15:345")
    assert result.__class__ is Allele, f'Expected parse("B*15:345") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:345") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_346():
    result = parse("B*15:346")
    assert result.__class__ is Allele, f'Expected parse("B*15:346") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:346") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_347():
    result = parse("B*15:347")
    assert result.__class__ is Allele, f'Expected parse("B*15:347") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:347") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_348():
    result = parse("B*15:348")
    assert result.__class__ is Allele, f'Expected parse("B*15:348") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:348") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_349_01():
    result = parse("B*15:349:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:349:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:349:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_349_02():
    result = parse("B*15:349:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:349:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:349:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_34_01():
    result = parse("B*15:34:01")
    assert result.__class__ is Allele, f'Expected parse("B*15:34:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:34:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_34_02():
    result = parse("B*15:34:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:34:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:34:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_35():
    result = parse("B*15:35")
    assert result.__class__ is Allele, f'Expected parse("B*15:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_350():
    result = parse("B*15:350")
    assert result.__class__ is Allele, f'Expected parse("B*15:350") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:350") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_351():
    result = parse("B*15:351")
    assert result.__class__ is Allele, f'Expected parse("B*15:351") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:351") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_352():
    result = parse("B*15:352")
    assert result.__class__ is Allele, f'Expected parse("B*15:352") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:352") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_353():
    result = parse("B*15:353")
    assert result.__class__ is Allele, f'Expected parse("B*15:353") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:353") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_354():
    result = parse("B*15:354")
    assert result.__class__ is Allele, f'Expected parse("B*15:354") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:354") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_355():
    result = parse("B*15:355")
    assert result.__class__ is Allele, f'Expected parse("B*15:355") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:355") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_356():
    result = parse("B*15:356")
    assert result.__class__ is Allele, f'Expected parse("B*15:356") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:356") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_357():
    result = parse("B*15:357")
    assert result.__class__ is Allele, f'Expected parse("B*15:357") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:357") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_358():
    result = parse("B*15:358")
    assert result.__class__ is Allele, f'Expected parse("B*15:358") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:358") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_359():
    result = parse("B*15:359")
    assert result.__class__ is Allele, f'Expected parse("B*15:359") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:359") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_36():
    result = parse("B*15:36")
    assert result.__class__ is Allele, f'Expected parse("B*15:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_360():
    result = parse("B*15:360")
    assert result.__class__ is Allele, f'Expected parse("B*15:360") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:360") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_361():
    result = parse("B*15:361")
    assert result.__class__ is Allele, f'Expected parse("B*15:361") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:361") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_362():
    result = parse("B*15:362")
    assert result.__class__ is Allele, f'Expected parse("B*15:362") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:362") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_363_01():
    result = parse("B*15:363:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:363:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:363:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_363_02():
    result = parse("B*15:363:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:363:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:363:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_364():
    result = parse("B*15:364")
    assert result.__class__ is Allele, f'Expected parse("B*15:364") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:364") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_365():
    result = parse("B*15:365")
    assert result.__class__ is Allele, f'Expected parse("B*15:365") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:365") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_366():
    result = parse("B*15:366")
    assert result.__class__ is Allele, f'Expected parse("B*15:366") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:366") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_367():
    result = parse("B*15:367")
    assert result.__class__ is Allele, f'Expected parse("B*15:367") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:367") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_368():
    result = parse("B*15:368")
    assert result.__class__ is Allele, f'Expected parse("B*15:368") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:368") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_369():
    result = parse("B*15:369")
    assert result.__class__ is Allele, f'Expected parse("B*15:369") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:369") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_37():
    result = parse("B*15:37")
    assert result.__class__ is Allele, f'Expected parse("B*15:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_370():
    result = parse("B*15:370")
    assert result.__class__ is Allele, f'Expected parse("B*15:370") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:370") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_371():
    result = parse("B*15:371")
    assert result.__class__ is Allele, f'Expected parse("B*15:371") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:371") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_372():
    result = parse("B*15:372")
    assert result.__class__ is Allele, f'Expected parse("B*15:372") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:372") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_373():
    result = parse("B*15:373")
    assert result.__class__ is Allele, f'Expected parse("B*15:373") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:373") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_374():
    result = parse("B*15:374")
    assert result.__class__ is Allele, f'Expected parse("B*15:374") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:374") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_375N():
    result = parse("B*15:375N")
    assert result.__class__ is Allele, f'Expected parse("B*15:375N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:375N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_376():
    result = parse("B*15:376")
    assert result.__class__ is Allele, f'Expected parse("B*15:376") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:376") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_377Q():
    result = parse("B*15:377Q")
    assert result.__class__ is Allele, f'Expected parse("B*15:377Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:377Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_378():
    result = parse("B*15:378")
    assert result.__class__ is Allele, f'Expected parse("B*15:378") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:378") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_379():
    result = parse("B*15:379")
    assert result.__class__ is Allele, f'Expected parse("B*15:379") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:379") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_380N():
    result = parse("B*15:380N")
    assert result.__class__ is Allele, f'Expected parse("B*15:380N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:380N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_381():
    result = parse("B*15:381")
    assert result.__class__ is Allele, f'Expected parse("B*15:381") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:381") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_382():
    result = parse("B*15:382")
    assert result.__class__ is Allele, f'Expected parse("B*15:382") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:382") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_383():
    result = parse("B*15:383")
    assert result.__class__ is Allele, f'Expected parse("B*15:383") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:383") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_384():
    result = parse("B*15:384")
    assert result.__class__ is Allele, f'Expected parse("B*15:384") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:384") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_385():
    result = parse("B*15:385")
    assert result.__class__ is Allele, f'Expected parse("B*15:385") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:385") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_386():
    result = parse("B*15:386")
    assert result.__class__ is Allele, f'Expected parse("B*15:386") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:386") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_387():
    result = parse("B*15:387")
    assert result.__class__ is Allele, f'Expected parse("B*15:387") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:387") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_388():
    result = parse("B*15:388")
    assert result.__class__ is Allele, f'Expected parse("B*15:388") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:388") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_389():
    result = parse("B*15:389")
    assert result.__class__ is Allele, f'Expected parse("B*15:389") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:389") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_38_01():
    result = parse("B*15:38:01")
    assert result.__class__ is Allele, f'Expected parse("B*15:38:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:38:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_38_02():
    result = parse("B*15:38:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:38:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:38:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_390():
    result = parse("B*15:390")
    assert result.__class__ is Allele, f'Expected parse("B*15:390") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:390") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_391():
    result = parse("B*15:391")
    assert result.__class__ is Allele, f'Expected parse("B*15:391") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:391") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_392():
    result = parse("B*15:392")
    assert result.__class__ is Allele, f'Expected parse("B*15:392") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:392") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_393():
    result = parse("B*15:393")
    assert result.__class__ is Allele, f'Expected parse("B*15:393") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:393") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_394():
    result = parse("B*15:394")
    assert result.__class__ is Allele, f'Expected parse("B*15:394") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:394") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_395():
    result = parse("B*15:395")
    assert result.__class__ is Allele, f'Expected parse("B*15:395") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:395") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_396():
    result = parse("B*15:396")
    assert result.__class__ is Allele, f'Expected parse("B*15:396") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:396") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_397():
    result = parse("B*15:397")
    assert result.__class__ is Allele, f'Expected parse("B*15:397") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:397") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_398():
    result = parse("B*15:398")
    assert result.__class__ is Allele, f'Expected parse("B*15:398") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:398") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_399():
    result = parse("B*15:399")
    assert result.__class__ is Allele, f'Expected parse("B*15:399") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:399") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_39_01_01():
    result = parse("B*15:39:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:39:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:39:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_39_01_02():
    result = parse("B*15:39:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:39:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:39:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_39_02():
    result = parse("B*15:39:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:39:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:39:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_400N():
    result = parse("B*15:400N")
    assert result.__class__ is Allele, f'Expected parse("B*15:400N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:400N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_401():
    result = parse("B*15:401")
    assert result.__class__ is Allele, f'Expected parse("B*15:401") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:401") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_402():
    result = parse("B*15:402")
    assert result.__class__ is Allele, f'Expected parse("B*15:402") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:402") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_403():
    result = parse("B*15:403")
    assert result.__class__ is Allele, f'Expected parse("B*15:403") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:403") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_404():
    result = parse("B*15:404")
    assert result.__class__ is Allele, f'Expected parse("B*15:404") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:404") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_405():
    result = parse("B*15:405")
    assert result.__class__ is Allele, f'Expected parse("B*15:405") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:405") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_406():
    result = parse("B*15:406")
    assert result.__class__ is Allele, f'Expected parse("B*15:406") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:406") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_407():
    result = parse("B*15:407")
    assert result.__class__ is Allele, f'Expected parse("B*15:407") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:407") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_408():
    result = parse("B*15:408")
    assert result.__class__ is Allele, f'Expected parse("B*15:408") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:408") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_409():
    result = parse("B*15:409")
    assert result.__class__ is Allele, f'Expected parse("B*15:409") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:409") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_40_01():
    result = parse("B*15:40:01")
    assert result.__class__ is Allele, f'Expected parse("B*15:40:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:40:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_40_02():
    result = parse("B*15:40:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:40:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:40:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_410():
    result = parse("B*15:410")
    assert result.__class__ is Allele, f'Expected parse("B*15:410") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:410") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_411():
    result = parse("B*15:411")
    assert result.__class__ is Allele, f'Expected parse("B*15:411") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:411") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_412():
    result = parse("B*15:412")
    assert result.__class__ is Allele, f'Expected parse("B*15:412") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:412") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_413():
    result = parse("B*15:413")
    assert result.__class__ is Allele, f'Expected parse("B*15:413") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:413") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_414():
    result = parse("B*15:414")
    assert result.__class__ is Allele, f'Expected parse("B*15:414") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:414") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_415():
    result = parse("B*15:415")
    assert result.__class__ is Allele, f'Expected parse("B*15:415") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:415") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_416():
    result = parse("B*15:416")
    assert result.__class__ is Allele, f'Expected parse("B*15:416") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:416") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_417():
    result = parse("B*15:417")
    assert result.__class__ is Allele, f'Expected parse("B*15:417") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:417") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_418():
    result = parse("B*15:418")
    assert result.__class__ is Allele, f'Expected parse("B*15:418") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:418") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_419():
    result = parse("B*15:419")
    assert result.__class__ is Allele, f'Expected parse("B*15:419") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:419") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_42():
    result = parse("B*15:42")
    assert result.__class__ is Allele, f'Expected parse("B*15:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_420():
    result = parse("B*15:420")
    assert result.__class__ is Allele, f'Expected parse("B*15:420") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:420") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_421():
    result = parse("B*15:421")
    assert result.__class__ is Allele, f'Expected parse("B*15:421") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:421") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_422():
    result = parse("B*15:422")
    assert result.__class__ is Allele, f'Expected parse("B*15:422") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:422") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_423():
    result = parse("B*15:423")
    assert result.__class__ is Allele, f'Expected parse("B*15:423") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:423") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_424():
    result = parse("B*15:424")
    assert result.__class__ is Allele, f'Expected parse("B*15:424") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:424") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_425():
    result = parse("B*15:425")
    assert result.__class__ is Allele, f'Expected parse("B*15:425") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:425") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_426():
    result = parse("B*15:426")
    assert result.__class__ is Allele, f'Expected parse("B*15:426") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:426") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_427():
    result = parse("B*15:427")
    assert result.__class__ is Allele, f'Expected parse("B*15:427") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:427") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_428():
    result = parse("B*15:428")
    assert result.__class__ is Allele, f'Expected parse("B*15:428") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:428") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_429():
    result = parse("B*15:429")
    assert result.__class__ is Allele, f'Expected parse("B*15:429") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:429") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_43():
    result = parse("B*15:43")
    assert result.__class__ is Allele, f'Expected parse("B*15:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_430():
    result = parse("B*15:430")
    assert result.__class__ is Allele, f'Expected parse("B*15:430") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:430") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_431():
    result = parse("B*15:431")
    assert result.__class__ is Allele, f'Expected parse("B*15:431") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:431") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_432():
    result = parse("B*15:432")
    assert result.__class__ is Allele, f'Expected parse("B*15:432") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:432") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_433():
    result = parse("B*15:433")
    assert result.__class__ is Allele, f'Expected parse("B*15:433") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:433") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_434():
    result = parse("B*15:434")
    assert result.__class__ is Allele, f'Expected parse("B*15:434") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:434") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_435():
    result = parse("B*15:435")
    assert result.__class__ is Allele, f'Expected parse("B*15:435") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:435") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_436():
    result = parse("B*15:436")
    assert result.__class__ is Allele, f'Expected parse("B*15:436") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:436") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_437():
    result = parse("B*15:437")
    assert result.__class__ is Allele, f'Expected parse("B*15:437") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:437") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_438():
    result = parse("B*15:438")
    assert result.__class__ is Allele, f'Expected parse("B*15:438") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:438") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_439():
    result = parse("B*15:439")
    assert result.__class__ is Allele, f'Expected parse("B*15:439") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:439") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_44():
    result = parse("B*15:44")
    assert result.__class__ is Allele, f'Expected parse("B*15:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_440():
    result = parse("B*15:440")
    assert result.__class__ is Allele, f'Expected parse("B*15:440") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:440") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_441():
    result = parse("B*15:441")
    assert result.__class__ is Allele, f'Expected parse("B*15:441") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:441") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_442():
    result = parse("B*15:442")
    assert result.__class__ is Allele, f'Expected parse("B*15:442") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:442") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_443():
    result = parse("B*15:443")
    assert result.__class__ is Allele, f'Expected parse("B*15:443") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:443") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_444():
    result = parse("B*15:444")
    assert result.__class__ is Allele, f'Expected parse("B*15:444") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:444") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_445():
    result = parse("B*15:445")
    assert result.__class__ is Allele, f'Expected parse("B*15:445") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:445") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_446():
    result = parse("B*15:446")
    assert result.__class__ is Allele, f'Expected parse("B*15:446") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:446") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_447():
    result = parse("B*15:447")
    assert result.__class__ is Allele, f'Expected parse("B*15:447") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:447") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_448():
    result = parse("B*15:448")
    assert result.__class__ is Allele, f'Expected parse("B*15:448") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:448") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_449():
    result = parse("B*15:449")
    assert result.__class__ is Allele, f'Expected parse("B*15:449") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:449") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_45():
    result = parse("B*15:45")
    assert result.__class__ is Allele, f'Expected parse("B*15:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_450():
    result = parse("B*15:450")
    assert result.__class__ is Allele, f'Expected parse("B*15:450") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:450") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_451():
    result = parse("B*15:451")
    assert result.__class__ is Allele, f'Expected parse("B*15:451") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:451") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_452():
    result = parse("B*15:452")
    assert result.__class__ is Allele, f'Expected parse("B*15:452") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:452") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_453():
    result = parse("B*15:453")
    assert result.__class__ is Allele, f'Expected parse("B*15:453") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:453") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_454N():
    result = parse("B*15:454N")
    assert result.__class__ is Allele, f'Expected parse("B*15:454N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:454N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_455():
    result = parse("B*15:455")
    assert result.__class__ is Allele, f'Expected parse("B*15:455") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:455") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_456():
    result = parse("B*15:456")
    assert result.__class__ is Allele, f'Expected parse("B*15:456") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:456") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_457():
    result = parse("B*15:457")
    assert result.__class__ is Allele, f'Expected parse("B*15:457") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:457") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_458():
    result = parse("B*15:458")
    assert result.__class__ is Allele, f'Expected parse("B*15:458") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:458") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_459():
    result = parse("B*15:459")
    assert result.__class__ is Allele, f'Expected parse("B*15:459") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:459") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_46():
    result = parse("B*15:46")
    assert result.__class__ is Allele, f'Expected parse("B*15:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_460():
    result = parse("B*15:460")
    assert result.__class__ is Allele, f'Expected parse("B*15:460") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:460") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_461():
    result = parse("B*15:461")
    assert result.__class__ is Allele, f'Expected parse("B*15:461") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:461") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_462():
    result = parse("B*15:462")
    assert result.__class__ is Allele, f'Expected parse("B*15:462") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:462") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_463N():
    result = parse("B*15:463N")
    assert result.__class__ is Allele, f'Expected parse("B*15:463N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:463N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_464():
    result = parse("B*15:464")
    assert result.__class__ is Allele, f'Expected parse("B*15:464") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:464") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_465():
    result = parse("B*15:465")
    assert result.__class__ is Allele, f'Expected parse("B*15:465") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:465") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_466():
    result = parse("B*15:466")
    assert result.__class__ is Allele, f'Expected parse("B*15:466") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:466") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_467():
    result = parse("B*15:467")
    assert result.__class__ is Allele, f'Expected parse("B*15:467") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:467") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_468():
    result = parse("B*15:468")
    assert result.__class__ is Allele, f'Expected parse("B*15:468") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:468") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_469():
    result = parse("B*15:469")
    assert result.__class__ is Allele, f'Expected parse("B*15:469") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:469") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_470():
    result = parse("B*15:470")
    assert result.__class__ is Allele, f'Expected parse("B*15:470") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:470") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_471():
    result = parse("B*15:471")
    assert result.__class__ is Allele, f'Expected parse("B*15:471") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:471") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_472():
    result = parse("B*15:472")
    assert result.__class__ is Allele, f'Expected parse("B*15:472") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:472") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_473():
    result = parse("B*15:473")
    assert result.__class__ is Allele, f'Expected parse("B*15:473") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:473") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_474():
    result = parse("B*15:474")
    assert result.__class__ is Allele, f'Expected parse("B*15:474") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:474") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_475():
    result = parse("B*15:475")
    assert result.__class__ is Allele, f'Expected parse("B*15:475") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:475") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_476():
    result = parse("B*15:476")
    assert result.__class__ is Allele, f'Expected parse("B*15:476") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:476") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_477():
    result = parse("B*15:477")
    assert result.__class__ is Allele, f'Expected parse("B*15:477") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:477") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_478():
    result = parse("B*15:478")
    assert result.__class__ is Allele, f'Expected parse("B*15:478") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:478") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_479():
    result = parse("B*15:479")
    assert result.__class__ is Allele, f'Expected parse("B*15:479") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:479") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_47_01():
    result = parse("B*15:47:01")
    assert result.__class__ is Allele, f'Expected parse("B*15:47:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:47:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_47_02():
    result = parse("B*15:47:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:47:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:47:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_48():
    result = parse("B*15:48")
    assert result.__class__ is Allele, f'Expected parse("B*15:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_480():
    result = parse("B*15:480")
    assert result.__class__ is Allele, f'Expected parse("B*15:480") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:480") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_481():
    result = parse("B*15:481")
    assert result.__class__ is Allele, f'Expected parse("B*15:481") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:481") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_482():
    result = parse("B*15:482")
    assert result.__class__ is Allele, f'Expected parse("B*15:482") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:482") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_483N():
    result = parse("B*15:483N")
    assert result.__class__ is Allele, f'Expected parse("B*15:483N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:483N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_484():
    result = parse("B*15:484")
    assert result.__class__ is Allele, f'Expected parse("B*15:484") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:484") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_485():
    result = parse("B*15:485")
    assert result.__class__ is Allele, f'Expected parse("B*15:485") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:485") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_486():
    result = parse("B*15:486")
    assert result.__class__ is Allele, f'Expected parse("B*15:486") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:486") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_487N():
    result = parse("B*15:487N")
    assert result.__class__ is Allele, f'Expected parse("B*15:487N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:487N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_488():
    result = parse("B*15:488")
    assert result.__class__ is Allele, f'Expected parse("B*15:488") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:488") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_489():
    result = parse("B*15:489")
    assert result.__class__ is Allele, f'Expected parse("B*15:489") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:489") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_49():
    result = parse("B*15:49")
    assert result.__class__ is Allele, f'Expected parse("B*15:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_490():
    result = parse("B*15:490")
    assert result.__class__ is Allele, f'Expected parse("B*15:490") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:490") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_491():
    result = parse("B*15:491")
    assert result.__class__ is Allele, f'Expected parse("B*15:491") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:491") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_492():
    result = parse("B*15:492")
    assert result.__class__ is Allele, f'Expected parse("B*15:492") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:492") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_493():
    result = parse("B*15:493")
    assert result.__class__ is Allele, f'Expected parse("B*15:493") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:493") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_494():
    result = parse("B*15:494")
    assert result.__class__ is Allele, f'Expected parse("B*15:494") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:494") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_495():
    result = parse("B*15:495")
    assert result.__class__ is Allele, f'Expected parse("B*15:495") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:495") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_496N():
    result = parse("B*15:496N")
    assert result.__class__ is Allele, f'Expected parse("B*15:496N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:496N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_497():
    result = parse("B*15:497")
    assert result.__class__ is Allele, f'Expected parse("B*15:497") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:497") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_498():
    result = parse("B*15:498")
    assert result.__class__ is Allele, f'Expected parse("B*15:498") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:498") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_499():
    result = parse("B*15:499")
    assert result.__class__ is Allele, f'Expected parse("B*15:499") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:499") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_50():
    result = parse("B*15:50")
    assert result.__class__ is Allele, f'Expected parse("B*15:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_500():
    result = parse("B*15:500")
    assert result.__class__ is Allele, f'Expected parse("B*15:500") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:500") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_501():
    result = parse("B*15:501")
    assert result.__class__ is Allele, f'Expected parse("B*15:501") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:501") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_502():
    result = parse("B*15:502")
    assert result.__class__ is Allele, f'Expected parse("B*15:502") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:502") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_503():
    result = parse("B*15:503")
    assert result.__class__ is Allele, f'Expected parse("B*15:503") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:503") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_504():
    result = parse("B*15:504")
    assert result.__class__ is Allele, f'Expected parse("B*15:504") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:504") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_505():
    result = parse("B*15:505")
    assert result.__class__ is Allele, f'Expected parse("B*15:505") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:505") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_506():
    result = parse("B*15:506")
    assert result.__class__ is Allele, f'Expected parse("B*15:506") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:506") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_507():
    result = parse("B*15:507")
    assert result.__class__ is Allele, f'Expected parse("B*15:507") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:507") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_508():
    result = parse("B*15:508")
    assert result.__class__ is Allele, f'Expected parse("B*15:508") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:508") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_509():
    result = parse("B*15:509")
    assert result.__class__ is Allele, f'Expected parse("B*15:509") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:509") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_51():
    result = parse("B*15:51")
    assert result.__class__ is Allele, f'Expected parse("B*15:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_510():
    result = parse("B*15:510")
    assert result.__class__ is Allele, f'Expected parse("B*15:510") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:510") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_511():
    result = parse("B*15:511")
    assert result.__class__ is Allele, f'Expected parse("B*15:511") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:511") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_512():
    result = parse("B*15:512")
    assert result.__class__ is Allele, f'Expected parse("B*15:512") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:512") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_513():
    result = parse("B*15:513")
    assert result.__class__ is Allele, f'Expected parse("B*15:513") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:513") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_514():
    result = parse("B*15:514")
    assert result.__class__ is Allele, f'Expected parse("B*15:514") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:514") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_515():
    result = parse("B*15:515")
    assert result.__class__ is Allele, f'Expected parse("B*15:515") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:515") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_516():
    result = parse("B*15:516")
    assert result.__class__ is Allele, f'Expected parse("B*15:516") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:516") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_517():
    result = parse("B*15:517")
    assert result.__class__ is Allele, f'Expected parse("B*15:517") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:517") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_518():
    result = parse("B*15:518")
    assert result.__class__ is Allele, f'Expected parse("B*15:518") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:518") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_519():
    result = parse("B*15:519")
    assert result.__class__ is Allele, f'Expected parse("B*15:519") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:519") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_52():
    result = parse("B*15:52")
    assert result.__class__ is Allele, f'Expected parse("B*15:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_520Q():
    result = parse("B*15:520Q")
    assert result.__class__ is Allele, f'Expected parse("B*15:520Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:520Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_521():
    result = parse("B*15:521")
    assert result.__class__ is Allele, f'Expected parse("B*15:521") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:521") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_522():
    result = parse("B*15:522")
    assert result.__class__ is Allele, f'Expected parse("B*15:522") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:522") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_523():
    result = parse("B*15:523")
    assert result.__class__ is Allele, f'Expected parse("B*15:523") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:523") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_524():
    result = parse("B*15:524")
    assert result.__class__ is Allele, f'Expected parse("B*15:524") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:524") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_525():
    result = parse("B*15:525")
    assert result.__class__ is Allele, f'Expected parse("B*15:525") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:525") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_526():
    result = parse("B*15:526")
    assert result.__class__ is Allele, f'Expected parse("B*15:526") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:526") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_527():
    result = parse("B*15:527")
    assert result.__class__ is Allele, f'Expected parse("B*15:527") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:527") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_528N():
    result = parse("B*15:528N")
    assert result.__class__ is Allele, f'Expected parse("B*15:528N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:528N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_529():
    result = parse("B*15:529")
    assert result.__class__ is Allele, f'Expected parse("B*15:529") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:529") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_53():
    result = parse("B*15:53")
    assert result.__class__ is Allele, f'Expected parse("B*15:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_530():
    result = parse("B*15:530")
    assert result.__class__ is Allele, f'Expected parse("B*15:530") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:530") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_531():
    result = parse("B*15:531")
    assert result.__class__ is Allele, f'Expected parse("B*15:531") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:531") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_532():
    result = parse("B*15:532")
    assert result.__class__ is Allele, f'Expected parse("B*15:532") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:532") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_533():
    result = parse("B*15:533")
    assert result.__class__ is Allele, f'Expected parse("B*15:533") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:533") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_534():
    result = parse("B*15:534")
    assert result.__class__ is Allele, f'Expected parse("B*15:534") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:534") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_535():
    result = parse("B*15:535")
    assert result.__class__ is Allele, f'Expected parse("B*15:535") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:535") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_536():
    result = parse("B*15:536")
    assert result.__class__ is Allele, f'Expected parse("B*15:536") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:536") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_537():
    result = parse("B*15:537")
    assert result.__class__ is Allele, f'Expected parse("B*15:537") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:537") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_538():
    result = parse("B*15:538")
    assert result.__class__ is Allele, f'Expected parse("B*15:538") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:538") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_539():
    result = parse("B*15:539")
    assert result.__class__ is Allele, f'Expected parse("B*15:539") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:539") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_54():
    result = parse("B*15:54")
    assert result.__class__ is Allele, f'Expected parse("B*15:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_540N():
    result = parse("B*15:540N")
    assert result.__class__ is Allele, f'Expected parse("B*15:540N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:540N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_541():
    result = parse("B*15:541")
    assert result.__class__ is Allele, f'Expected parse("B*15:541") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:541") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_542():
    result = parse("B*15:542")
    assert result.__class__ is Allele, f'Expected parse("B*15:542") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:542") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_543():
    result = parse("B*15:543")
    assert result.__class__ is Allele, f'Expected parse("B*15:543") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:543") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_544N():
    result = parse("B*15:544N")
    assert result.__class__ is Allele, f'Expected parse("B*15:544N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:544N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_545():
    result = parse("B*15:545")
    assert result.__class__ is Allele, f'Expected parse("B*15:545") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:545") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_546Q():
    result = parse("B*15:546Q")
    assert result.__class__ is Allele, f'Expected parse("B*15:546Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:546Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_547():
    result = parse("B*15:547")
    assert result.__class__ is Allele, f'Expected parse("B*15:547") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:547") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_548():
    result = parse("B*15:548")
    assert result.__class__ is Allele, f'Expected parse("B*15:548") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:548") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_549N():
    result = parse("B*15:549N")
    assert result.__class__ is Allele, f'Expected parse("B*15:549N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:549N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_55():
    result = parse("B*15:55")
    assert result.__class__ is Allele, f'Expected parse("B*15:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_550():
    result = parse("B*15:550")
    assert result.__class__ is Allele, f'Expected parse("B*15:550") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:550") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_551():
    result = parse("B*15:551")
    assert result.__class__ is Allele, f'Expected parse("B*15:551") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:551") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_552():
    result = parse("B*15:552")
    assert result.__class__ is Allele, f'Expected parse("B*15:552") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:552") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_553():
    result = parse("B*15:553")
    assert result.__class__ is Allele, f'Expected parse("B*15:553") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:553") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_554():
    result = parse("B*15:554")
    assert result.__class__ is Allele, f'Expected parse("B*15:554") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:554") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_555():
    result = parse("B*15:555")
    assert result.__class__ is Allele, f'Expected parse("B*15:555") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:555") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_556():
    result = parse("B*15:556")
    assert result.__class__ is Allele, f'Expected parse("B*15:556") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:556") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_557():
    result = parse("B*15:557")
    assert result.__class__ is Allele, f'Expected parse("B*15:557") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:557") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_558():
    result = parse("B*15:558")
    assert result.__class__ is Allele, f'Expected parse("B*15:558") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:558") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_559():
    result = parse("B*15:559")
    assert result.__class__ is Allele, f'Expected parse("B*15:559") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:559") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_56():
    result = parse("B*15:56")
    assert result.__class__ is Allele, f'Expected parse("B*15:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_560():
    result = parse("B*15:560")
    assert result.__class__ is Allele, f'Expected parse("B*15:560") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:560") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_561():
    result = parse("B*15:561")
    assert result.__class__ is Allele, f'Expected parse("B*15:561") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:561") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_562N():
    result = parse("B*15:562N")
    assert result.__class__ is Allele, f'Expected parse("B*15:562N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:562N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_563():
    result = parse("B*15:563")
    assert result.__class__ is Allele, f'Expected parse("B*15:563") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:563") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_564():
    result = parse("B*15:564")
    assert result.__class__ is Allele, f'Expected parse("B*15:564") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:564") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_565():
    result = parse("B*15:565")
    assert result.__class__ is Allele, f'Expected parse("B*15:565") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:565") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_566():
    result = parse("B*15:566")
    assert result.__class__ is Allele, f'Expected parse("B*15:566") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:566") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_567():
    result = parse("B*15:567")
    assert result.__class__ is Allele, f'Expected parse("B*15:567") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:567") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_568():
    result = parse("B*15:568")
    assert result.__class__ is Allele, f'Expected parse("B*15:568") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:568") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_57():
    result = parse("B*15:57")
    assert result.__class__ is Allele, f'Expected parse("B*15:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_58():
    result = parse("B*15:58")
    assert result.__class__ is Allele, f'Expected parse("B*15:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_60():
    result = parse("B*15:60")
    assert result.__class__ is Allele, f'Expected parse("B*15:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_61():
    result = parse("B*15:61")
    assert result.__class__ is Allele, f'Expected parse("B*15:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_62():
    result = parse("B*15:62")
    assert result.__class__ is Allele, f'Expected parse("B*15:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_63():
    result = parse("B*15:63")
    assert result.__class__ is Allele, f'Expected parse("B*15:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_64_01():
    result = parse("B*15:64:01")
    assert result.__class__ is Allele, f'Expected parse("B*15:64:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:64:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_64_02():
    result = parse("B*15:64:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:64:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:64:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_65():
    result = parse("B*15:65")
    assert result.__class__ is Allele, f'Expected parse("B*15:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_66():
    result = parse("B*15:66")
    assert result.__class__ is Allele, f'Expected parse("B*15:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_67():
    result = parse("B*15:67")
    assert result.__class__ is Allele, f'Expected parse("B*15:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_68():
    result = parse("B*15:68")
    assert result.__class__ is Allele, f'Expected parse("B*15:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_69():
    result = parse("B*15:69")
    assert result.__class__ is Allele, f'Expected parse("B*15:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_70():
    result = parse("B*15:70")
    assert result.__class__ is Allele, f'Expected parse("B*15:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_71():
    result = parse("B*15:71")
    assert result.__class__ is Allele, f'Expected parse("B*15:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_72():
    result = parse("B*15:72")
    assert result.__class__ is Allele, f'Expected parse("B*15:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_73_01_01():
    result = parse("B*15:73:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:73:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:73:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_73_01_02():
    result = parse("B*15:73:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:73:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:73:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_74():
    result = parse("B*15:74")
    assert result.__class__ is Allele, f'Expected parse("B*15:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_75():
    result = parse("B*15:75")
    assert result.__class__ is Allele, f'Expected parse("B*15:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_76():
    result = parse("B*15:76")
    assert result.__class__ is Allele, f'Expected parse("B*15:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_77():
    result = parse("B*15:77")
    assert result.__class__ is Allele, f'Expected parse("B*15:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_78_01_01():
    result = parse("B*15:78:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:78:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:78:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_78_01_02():
    result = parse("B*15:78:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:78:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:78:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_78_02():
    result = parse("B*15:78:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:78:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:78:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_78_03():
    result = parse("B*15:78:03")
    assert result.__class__ is Allele, f'Expected parse("B*15:78:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:78:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_78_04():
    result = parse("B*15:78:04")
    assert result.__class__ is Allele, f'Expected parse("B*15:78:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:78:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_79N():
    result = parse("B*15:79N")
    assert result.__class__ is Allele, f'Expected parse("B*15:79N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:79N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_80():
    result = parse("B*15:80")
    assert result.__class__ is Allele, f'Expected parse("B*15:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_81():
    result = parse("B*15:81")
    assert result.__class__ is Allele, f'Expected parse("B*15:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_82():
    result = parse("B*15:82")
    assert result.__class__ is Allele, f'Expected parse("B*15:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_83_01_01():
    result = parse("B*15:83:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:83:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:83:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_83_01_02():
    result = parse("B*15:83:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*15:83:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*15:83:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_84():
    result = parse("B*15:84")
    assert result.__class__ is Allele, f'Expected parse("B*15:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_85():
    result = parse("B*15:85")
    assert result.__class__ is Allele, f'Expected parse("B*15:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_86():
    result = parse("B*15:86")
    assert result.__class__ is Allele, f'Expected parse("B*15:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_87():
    result = parse("B*15:87")
    assert result.__class__ is Allele, f'Expected parse("B*15:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_88():
    result = parse("B*15:88")
    assert result.__class__ is Allele, f'Expected parse("B*15:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_89_01():
    result = parse("B*15:89:01")
    assert result.__class__ is Allele, f'Expected parse("B*15:89:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:89:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_89_02():
    result = parse("B*15:89:02")
    assert result.__class__ is Allele, f'Expected parse("B*15:89:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*15:89:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_90():
    result = parse("B*15:90")
    assert result.__class__ is Allele, f'Expected parse("B*15:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_91():
    result = parse("B*15:91")
    assert result.__class__ is Allele, f'Expected parse("B*15:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_92():
    result = parse("B*15:92")
    assert result.__class__ is Allele, f'Expected parse("B*15:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_93():
    result = parse("B*15:93")
    assert result.__class__ is Allele, f'Expected parse("B*15:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_94N():
    result = parse("B*15:94N")
    assert result.__class__ is Allele, f'Expected parse("B*15:94N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:94N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_95():
    result = parse("B*15:95")
    assert result.__class__ is Allele, f'Expected parse("B*15:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_96():
    result = parse("B*15:96")
    assert result.__class__ is Allele, f'Expected parse("B*15:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_97():
    result = parse("B*15:97")
    assert result.__class__ is Allele, f'Expected parse("B*15:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_98():
    result = parse("B*15:98")
    assert result.__class__ is Allele, f'Expected parse("B*15:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_15_99():
    result = parse("B*15:99")
    assert result.__class__ is Allele, f'Expected parse("B*15:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*15:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_01():
    result = parse("B*18:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_02():
    result = parse("B*18:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_03():
    result = parse("B*18:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_04():
    result = parse("B*18:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_05():
    result = parse("B*18:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_06():
    result = parse("B*18:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_07():
    result = parse("B*18:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_08():
    result = parse("B*18:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_09():
    result = parse("B*18:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_10():
    result = parse("B*18:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_11():
    result = parse("B*18:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_12Q():
    result = parse("B*18:01:01:12Q")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:12Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:12Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_13():
    result = parse("B*18:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_14():
    result = parse("B*18:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_15():
    result = parse("B*18:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_16():
    result = parse("B*18:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_17():
    result = parse("B*18:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_18():
    result = parse("B*18:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_19():
    result = parse("B*18:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_20():
    result = parse("B*18:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_21():
    result = parse("B*18:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_22():
    result = parse("B*18:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_23():
    result = parse("B*18:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_24():
    result = parse("B*18:01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_25():
    result = parse("B*18:01:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_26():
    result = parse("B*18:01:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_27():
    result = parse("B*18:01:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_28():
    result = parse("B*18:01:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_29():
    result = parse("B*18:01:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_30():
    result = parse("B*18:01:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_31():
    result = parse("B*18:01:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_32():
    result = parse("B*18:01:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_33():
    result = parse("B*18:01:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_34():
    result = parse("B*18:01:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_35():
    result = parse("B*18:01:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_36():
    result = parse("B*18:01:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_37():
    result = parse("B*18:01:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_38():
    result = parse("B*18:01:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_39():
    result = parse("B*18:01:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_40():
    result = parse("B*18:01:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_41():
    result = parse("B*18:01:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_42Q():
    result = parse("B*18:01:01:42Q")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:42Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:42Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_43():
    result = parse("B*18:01:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_44():
    result = parse("B*18:01:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_45():
    result = parse("B*18:01:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:45") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_46():
    result = parse("B*18:01:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:46") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_47():
    result = parse("B*18:01:01:47")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:47") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_48():
    result = parse("B*18:01:01:48")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:48") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:48") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_49():
    result = parse("B*18:01:01:49")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:49") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:49") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_50():
    result = parse("B*18:01:01:50")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:50") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:50") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_01_51():
    result = parse("B*18:01:01:51")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:01:51") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:01:51") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_02():
    result = parse("B*18:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_03():
    result = parse("B*18:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_04():
    result = parse("B*18:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_05():
    result = parse("B*18:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_06():
    result = parse("B*18:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_07():
    result = parse("B*18:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_08():
    result = parse("B*18:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_09():
    result = parse("B*18:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_10():
    result = parse("B*18:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_11():
    result = parse("B*18:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_12():
    result = parse("B*18:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_13():
    result = parse("B*18:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_14():
    result = parse("B*18:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_15():
    result = parse("B*18:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_16():
    result = parse("B*18:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_17():
    result = parse("B*18:01:17")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_18():
    result = parse("B*18:01:18")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_19():
    result = parse("B*18:01:19")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_20():
    result = parse("B*18:01:20")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_21():
    result = parse("B*18:01:21")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_22():
    result = parse("B*18:01:22")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_23():
    result = parse("B*18:01:23")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_24():
    result = parse("B*18:01:24")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_25():
    result = parse("B*18:01:25")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_26():
    result = parse("B*18:01:26")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_27():
    result = parse("B*18:01:27")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_28():
    result = parse("B*18:01:28")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_29():
    result = parse("B*18:01:29")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_30():
    result = parse("B*18:01:30")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_31():
    result = parse("B*18:01:31")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_32():
    result = parse("B*18:01:32")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_33_01():
    result = parse("B*18:01:33:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:33:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:33:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_33_02():
    result = parse("B*18:01:33:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:01:33:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:01:33:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_34():
    result = parse("B*18:01:34")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_35():
    result = parse("B*18:01:35")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_36():
    result = parse("B*18:01:36")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_37():
    result = parse("B*18:01:37")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_38():
    result = parse("B*18:01:38")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_39():
    result = parse("B*18:01:39")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_40():
    result = parse("B*18:01:40")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_01_41():
    result = parse("B*18:01:41")
    assert result.__class__ is Allele, f'Expected parse("B*18:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_02_01():
    result = parse("B*18:02:01")
    assert result.__class__ is Allele, f'Expected parse("B*18:02:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_02_02():
    result = parse("B*18:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*18:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_03_01_01():
    result = parse("B*18:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_03_01_02():
    result = parse("B*18:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_03_02():
    result = parse("B*18:03:02")
    assert result.__class__ is Allele, f'Expected parse("B*18:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_04_01():
    result = parse("B*18:04:01")
    assert result.__class__ is Allele, f'Expected parse("B*18:04:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_04_02():
    result = parse("B*18:04:02")
    assert result.__class__ is Allele, f'Expected parse("B*18:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_05_01_01():
    result = parse("B*18:05:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:05:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:05:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_05_01_02():
    result = parse("B*18:05:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:05:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:05:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_06():
    result = parse("B*18:06")
    assert result.__class__ is Allele, f'Expected parse("B*18:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_07_01():
    result = parse("B*18:07:01")
    assert result.__class__ is Allele, f'Expected parse("B*18:07:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_07_02():
    result = parse("B*18:07:02")
    assert result.__class__ is Allele, f'Expected parse("B*18:07:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_08():
    result = parse("B*18:08")
    assert result.__class__ is Allele, f'Expected parse("B*18:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_09():
    result = parse("B*18:09")
    assert result.__class__ is Allele, f'Expected parse("B*18:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_10():
    result = parse("B*18:10")
    assert result.__class__ is Allele, f'Expected parse("B*18:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_100():
    result = parse("B*18:100")
    assert result.__class__ is Allele, f'Expected parse("B*18:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_101():
    result = parse("B*18:101")
    assert result.__class__ is Allele, f'Expected parse("B*18:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_102():
    result = parse("B*18:102")
    assert result.__class__ is Allele, f'Expected parse("B*18:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_103():
    result = parse("B*18:103")
    assert result.__class__ is Allele, f'Expected parse("B*18:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_104():
    result = parse("B*18:104")
    assert result.__class__ is Allele, f'Expected parse("B*18:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_105():
    result = parse("B*18:105")
    assert result.__class__ is Allele, f'Expected parse("B*18:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_106Q():
    result = parse("B*18:106Q")
    assert result.__class__ is Allele, f'Expected parse("B*18:106Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:106Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_107():
    result = parse("B*18:107")
    assert result.__class__ is Allele, f'Expected parse("B*18:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_108():
    result = parse("B*18:108")
    assert result.__class__ is Allele, f'Expected parse("B*18:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_109():
    result = parse("B*18:109")
    assert result.__class__ is Allele, f'Expected parse("B*18:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_11():
    result = parse("B*18:11")
    assert result.__class__ is Allele, f'Expected parse("B*18:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_110():
    result = parse("B*18:110")
    assert result.__class__ is Allele, f'Expected parse("B*18:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_111():
    result = parse("B*18:111")
    assert result.__class__ is Allele, f'Expected parse("B*18:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_112():
    result = parse("B*18:112")
    assert result.__class__ is Allele, f'Expected parse("B*18:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_113():
    result = parse("B*18:113")
    assert result.__class__ is Allele, f'Expected parse("B*18:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_114():
    result = parse("B*18:114")
    assert result.__class__ is Allele, f'Expected parse("B*18:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_115():
    result = parse("B*18:115")
    assert result.__class__ is Allele, f'Expected parse("B*18:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_116():
    result = parse("B*18:116")
    assert result.__class__ is Allele, f'Expected parse("B*18:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_117():
    result = parse("B*18:117")
    assert result.__class__ is Allele, f'Expected parse("B*18:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_118():
    result = parse("B*18:118")
    assert result.__class__ is Allele, f'Expected parse("B*18:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_119():
    result = parse("B*18:119")
    assert result.__class__ is Allele, f'Expected parse("B*18:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_120():
    result = parse("B*18:120")
    assert result.__class__ is Allele, f'Expected parse("B*18:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_121():
    result = parse("B*18:121")
    assert result.__class__ is Allele, f'Expected parse("B*18:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_122():
    result = parse("B*18:122")
    assert result.__class__ is Allele, f'Expected parse("B*18:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_123():
    result = parse("B*18:123")
    assert result.__class__ is Allele, f'Expected parse("B*18:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_124():
    result = parse("B*18:124")
    assert result.__class__ is Allele, f'Expected parse("B*18:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_125():
    result = parse("B*18:125")
    assert result.__class__ is Allele, f'Expected parse("B*18:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_126():
    result = parse("B*18:126")
    assert result.__class__ is Allele, f'Expected parse("B*18:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_127():
    result = parse("B*18:127")
    assert result.__class__ is Allele, f'Expected parse("B*18:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_128():
    result = parse("B*18:128")
    assert result.__class__ is Allele, f'Expected parse("B*18:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_129():
    result = parse("B*18:129")
    assert result.__class__ is Allele, f'Expected parse("B*18:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_12_01():
    result = parse("B*18:12:01")
    assert result.__class__ is Allele, f'Expected parse("B*18:12:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:12:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_12_02():
    result = parse("B*18:12:02")
    assert result.__class__ is Allele, f'Expected parse("B*18:12:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:12:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_13():
    result = parse("B*18:13")
    assert result.__class__ is Allele, f'Expected parse("B*18:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_130():
    result = parse("B*18:130")
    assert result.__class__ is Allele, f'Expected parse("B*18:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_131_01_01():
    result = parse("B*18:131:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:131:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:131:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_131_01_02():
    result = parse("B*18:131:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:131:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:131:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_132():
    result = parse("B*18:132")
    assert result.__class__ is Allele, f'Expected parse("B*18:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_133():
    result = parse("B*18:133")
    assert result.__class__ is Allele, f'Expected parse("B*18:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_134():
    result = parse("B*18:134")
    assert result.__class__ is Allele, f'Expected parse("B*18:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_135_01_01():
    result = parse("B*18:135:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:135:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:135:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_135_01_02():
    result = parse("B*18:135:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:135:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:135:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_136():
    result = parse("B*18:136")
    assert result.__class__ is Allele, f'Expected parse("B*18:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_137():
    result = parse("B*18:137")
    assert result.__class__ is Allele, f'Expected parse("B*18:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_138N():
    result = parse("B*18:138N")
    assert result.__class__ is Allele, f'Expected parse("B*18:138N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:138N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_139():
    result = parse("B*18:139")
    assert result.__class__ is Allele, f'Expected parse("B*18:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_14():
    result = parse("B*18:14")
    assert result.__class__ is Allele, f'Expected parse("B*18:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_140():
    result = parse("B*18:140")
    assert result.__class__ is Allele, f'Expected parse("B*18:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_141():
    result = parse("B*18:141")
    assert result.__class__ is Allele, f'Expected parse("B*18:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_142():
    result = parse("B*18:142")
    assert result.__class__ is Allele, f'Expected parse("B*18:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_143():
    result = parse("B*18:143")
    assert result.__class__ is Allele, f'Expected parse("B*18:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_144():
    result = parse("B*18:144")
    assert result.__class__ is Allele, f'Expected parse("B*18:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_145():
    result = parse("B*18:145")
    assert result.__class__ is Allele, f'Expected parse("B*18:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_146():
    result = parse("B*18:146")
    assert result.__class__ is Allele, f'Expected parse("B*18:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_147():
    result = parse("B*18:147")
    assert result.__class__ is Allele, f'Expected parse("B*18:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_148():
    result = parse("B*18:148")
    assert result.__class__ is Allele, f'Expected parse("B*18:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_149():
    result = parse("B*18:149")
    assert result.__class__ is Allele, f'Expected parse("B*18:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_15():
    result = parse("B*18:15")
    assert result.__class__ is Allele, f'Expected parse("B*18:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_150():
    result = parse("B*18:150")
    assert result.__class__ is Allele, f'Expected parse("B*18:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_151():
    result = parse("B*18:151")
    assert result.__class__ is Allele, f'Expected parse("B*18:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_152():
    result = parse("B*18:152")
    assert result.__class__ is Allele, f'Expected parse("B*18:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_153():
    result = parse("B*18:153")
    assert result.__class__ is Allele, f'Expected parse("B*18:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_154N():
    result = parse("B*18:154N")
    assert result.__class__ is Allele, f'Expected parse("B*18:154N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:154N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_155():
    result = parse("B*18:155")
    assert result.__class__ is Allele, f'Expected parse("B*18:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_156_01_01():
    result = parse("B*18:156:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:156:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:156:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_156_01_02():
    result = parse("B*18:156:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:156:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:156:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_157_01_01():
    result = parse("B*18:157:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:157:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:157:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_157_01_02():
    result = parse("B*18:157:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:157:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:157:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_158():
    result = parse("B*18:158")
    assert result.__class__ is Allele, f'Expected parse("B*18:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_159():
    result = parse("B*18:159")
    assert result.__class__ is Allele, f'Expected parse("B*18:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_160():
    result = parse("B*18:160")
    assert result.__class__ is Allele, f'Expected parse("B*18:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_161():
    result = parse("B*18:161")
    assert result.__class__ is Allele, f'Expected parse("B*18:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_162():
    result = parse("B*18:162")
    assert result.__class__ is Allele, f'Expected parse("B*18:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_163():
    result = parse("B*18:163")
    assert result.__class__ is Allele, f'Expected parse("B*18:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_164():
    result = parse("B*18:164")
    assert result.__class__ is Allele, f'Expected parse("B*18:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_165():
    result = parse("B*18:165")
    assert result.__class__ is Allele, f'Expected parse("B*18:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_166():
    result = parse("B*18:166")
    assert result.__class__ is Allele, f'Expected parse("B*18:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_167():
    result = parse("B*18:167")
    assert result.__class__ is Allele, f'Expected parse("B*18:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_168():
    result = parse("B*18:168")
    assert result.__class__ is Allele, f'Expected parse("B*18:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_169():
    result = parse("B*18:169")
    assert result.__class__ is Allele, f'Expected parse("B*18:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_170():
    result = parse("B*18:170")
    assert result.__class__ is Allele, f'Expected parse("B*18:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_171():
    result = parse("B*18:171")
    assert result.__class__ is Allele, f'Expected parse("B*18:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_172():
    result = parse("B*18:172")
    assert result.__class__ is Allele, f'Expected parse("B*18:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_173():
    result = parse("B*18:173")
    assert result.__class__ is Allele, f'Expected parse("B*18:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_174():
    result = parse("B*18:174")
    assert result.__class__ is Allele, f'Expected parse("B*18:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_175():
    result = parse("B*18:175")
    assert result.__class__ is Allele, f'Expected parse("B*18:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_176():
    result = parse("B*18:176")
    assert result.__class__ is Allele, f'Expected parse("B*18:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_177():
    result = parse("B*18:177")
    assert result.__class__ is Allele, f'Expected parse("B*18:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_178():
    result = parse("B*18:178")
    assert result.__class__ is Allele, f'Expected parse("B*18:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_179():
    result = parse("B*18:179")
    assert result.__class__ is Allele, f'Expected parse("B*18:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_17N():
    result = parse("B*18:17N")
    assert result.__class__ is Allele, f'Expected parse("B*18:17N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:17N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_180():
    result = parse("B*18:180")
    assert result.__class__ is Allele, f'Expected parse("B*18:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_181():
    result = parse("B*18:181")
    assert result.__class__ is Allele, f'Expected parse("B*18:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_182N():
    result = parse("B*18:182N")
    assert result.__class__ is Allele, f'Expected parse("B*18:182N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:182N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_183():
    result = parse("B*18:183")
    assert result.__class__ is Allele, f'Expected parse("B*18:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_184():
    result = parse("B*18:184")
    assert result.__class__ is Allele, f'Expected parse("B*18:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_185():
    result = parse("B*18:185")
    assert result.__class__ is Allele, f'Expected parse("B*18:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_186():
    result = parse("B*18:186")
    assert result.__class__ is Allele, f'Expected parse("B*18:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_187():
    result = parse("B*18:187")
    assert result.__class__ is Allele, f'Expected parse("B*18:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_188():
    result = parse("B*18:188")
    assert result.__class__ is Allele, f'Expected parse("B*18:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_189():
    result = parse("B*18:189")
    assert result.__class__ is Allele, f'Expected parse("B*18:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_18_01_01():
    result = parse("B*18:18:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:18:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:18:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_18_01_02():
    result = parse("B*18:18:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*18:18:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*18:18:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_19():
    result = parse("B*18:19")
    assert result.__class__ is Allele, f'Expected parse("B*18:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_190():
    result = parse("B*18:190")
    assert result.__class__ is Allele, f'Expected parse("B*18:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_191():
    result = parse("B*18:191")
    assert result.__class__ is Allele, f'Expected parse("B*18:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_192():
    result = parse("B*18:192")
    assert result.__class__ is Allele, f'Expected parse("B*18:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_193():
    result = parse("B*18:193")
    assert result.__class__ is Allele, f'Expected parse("B*18:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_194():
    result = parse("B*18:194")
    assert result.__class__ is Allele, f'Expected parse("B*18:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_195():
    result = parse("B*18:195")
    assert result.__class__ is Allele, f'Expected parse("B*18:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_20():
    result = parse("B*18:20")
    assert result.__class__ is Allele, f'Expected parse("B*18:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_21():
    result = parse("B*18:21")
    assert result.__class__ is Allele, f'Expected parse("B*18:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_22():
    result = parse("B*18:22")
    assert result.__class__ is Allele, f'Expected parse("B*18:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_23N():
    result = parse("B*18:23N")
    assert result.__class__ is Allele, f'Expected parse("B*18:23N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:23N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_24():
    result = parse("B*18:24")
    assert result.__class__ is Allele, f'Expected parse("B*18:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_25():
    result = parse("B*18:25")
    assert result.__class__ is Allele, f'Expected parse("B*18:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_26():
    result = parse("B*18:26")
    assert result.__class__ is Allele, f'Expected parse("B*18:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_27():
    result = parse("B*18:27")
    assert result.__class__ is Allele, f'Expected parse("B*18:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_28():
    result = parse("B*18:28")
    assert result.__class__ is Allele, f'Expected parse("B*18:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_29():
    result = parse("B*18:29")
    assert result.__class__ is Allele, f'Expected parse("B*18:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_30():
    result = parse("B*18:30")
    assert result.__class__ is Allele, f'Expected parse("B*18:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_31():
    result = parse("B*18:31")
    assert result.__class__ is Allele, f'Expected parse("B*18:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_32():
    result = parse("B*18:32")
    assert result.__class__ is Allele, f'Expected parse("B*18:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_33():
    result = parse("B*18:33")
    assert result.__class__ is Allele, f'Expected parse("B*18:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_34():
    result = parse("B*18:34")
    assert result.__class__ is Allele, f'Expected parse("B*18:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_35():
    result = parse("B*18:35")
    assert result.__class__ is Allele, f'Expected parse("B*18:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_36():
    result = parse("B*18:36")
    assert result.__class__ is Allele, f'Expected parse("B*18:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_37_01():
    result = parse("B*18:37:01")
    assert result.__class__ is Allele, f'Expected parse("B*18:37:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:37:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_37_02():
    result = parse("B*18:37:02")
    assert result.__class__ is Allele, f'Expected parse("B*18:37:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:37:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_38():
    result = parse("B*18:38")
    assert result.__class__ is Allele, f'Expected parse("B*18:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_39():
    result = parse("B*18:39")
    assert result.__class__ is Allele, f'Expected parse("B*18:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_40():
    result = parse("B*18:40")
    assert result.__class__ is Allele, f'Expected parse("B*18:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_41():
    result = parse("B*18:41")
    assert result.__class__ is Allele, f'Expected parse("B*18:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_42():
    result = parse("B*18:42")
    assert result.__class__ is Allele, f'Expected parse("B*18:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_43():
    result = parse("B*18:43")
    assert result.__class__ is Allele, f'Expected parse("B*18:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_44_01():
    result = parse("B*18:44:01")
    assert result.__class__ is Allele, f'Expected parse("B*18:44:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:44:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_44_02():
    result = parse("B*18:44:02")
    assert result.__class__ is Allele, f'Expected parse("B*18:44:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:44:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_45():
    result = parse("B*18:45")
    assert result.__class__ is Allele, f'Expected parse("B*18:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_46():
    result = parse("B*18:46")
    assert result.__class__ is Allele, f'Expected parse("B*18:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_47():
    result = parse("B*18:47")
    assert result.__class__ is Allele, f'Expected parse("B*18:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_48():
    result = parse("B*18:48")
    assert result.__class__ is Allele, f'Expected parse("B*18:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_49():
    result = parse("B*18:49")
    assert result.__class__ is Allele, f'Expected parse("B*18:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_50():
    result = parse("B*18:50")
    assert result.__class__ is Allele, f'Expected parse("B*18:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_51():
    result = parse("B*18:51")
    assert result.__class__ is Allele, f'Expected parse("B*18:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_52():
    result = parse("B*18:52")
    assert result.__class__ is Allele, f'Expected parse("B*18:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_53():
    result = parse("B*18:53")
    assert result.__class__ is Allele, f'Expected parse("B*18:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_54():
    result = parse("B*18:54")
    assert result.__class__ is Allele, f'Expected parse("B*18:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_55():
    result = parse("B*18:55")
    assert result.__class__ is Allele, f'Expected parse("B*18:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_56():
    result = parse("B*18:56")
    assert result.__class__ is Allele, f'Expected parse("B*18:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_57_01():
    result = parse("B*18:57:01")
    assert result.__class__ is Allele, f'Expected parse("B*18:57:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:57:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_57_02():
    result = parse("B*18:57:02")
    assert result.__class__ is Allele, f'Expected parse("B*18:57:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:57:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_58():
    result = parse("B*18:58")
    assert result.__class__ is Allele, f'Expected parse("B*18:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_59():
    result = parse("B*18:59")
    assert result.__class__ is Allele, f'Expected parse("B*18:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_60():
    result = parse("B*18:60")
    assert result.__class__ is Allele, f'Expected parse("B*18:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_61():
    result = parse("B*18:61")
    assert result.__class__ is Allele, f'Expected parse("B*18:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_62():
    result = parse("B*18:62")
    assert result.__class__ is Allele, f'Expected parse("B*18:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_63():
    result = parse("B*18:63")
    assert result.__class__ is Allele, f'Expected parse("B*18:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_64():
    result = parse("B*18:64")
    assert result.__class__ is Allele, f'Expected parse("B*18:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_65():
    result = parse("B*18:65")
    assert result.__class__ is Allele, f'Expected parse("B*18:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_66():
    result = parse("B*18:66")
    assert result.__class__ is Allele, f'Expected parse("B*18:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_67():
    result = parse("B*18:67")
    assert result.__class__ is Allele, f'Expected parse("B*18:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_68():
    result = parse("B*18:68")
    assert result.__class__ is Allele, f'Expected parse("B*18:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_69():
    result = parse("B*18:69")
    assert result.__class__ is Allele, f'Expected parse("B*18:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_70():
    result = parse("B*18:70")
    assert result.__class__ is Allele, f'Expected parse("B*18:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_71():
    result = parse("B*18:71")
    assert result.__class__ is Allele, f'Expected parse("B*18:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_72_01():
    result = parse("B*18:72:01")
    assert result.__class__ is Allele, f'Expected parse("B*18:72:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:72:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_72_02():
    result = parse("B*18:72:02")
    assert result.__class__ is Allele, f'Expected parse("B*18:72:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:72:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_72_03():
    result = parse("B*18:72:03")
    assert result.__class__ is Allele, f'Expected parse("B*18:72:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:72:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_73():
    result = parse("B*18:73")
    assert result.__class__ is Allele, f'Expected parse("B*18:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_74N():
    result = parse("B*18:74N")
    assert result.__class__ is Allele, f'Expected parse("B*18:74N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:74N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_75():
    result = parse("B*18:75")
    assert result.__class__ is Allele, f'Expected parse("B*18:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_76():
    result = parse("B*18:76")
    assert result.__class__ is Allele, f'Expected parse("B*18:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_77():
    result = parse("B*18:77")
    assert result.__class__ is Allele, f'Expected parse("B*18:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_78():
    result = parse("B*18:78")
    assert result.__class__ is Allele, f'Expected parse("B*18:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_79():
    result = parse("B*18:79")
    assert result.__class__ is Allele, f'Expected parse("B*18:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_80():
    result = parse("B*18:80")
    assert result.__class__ is Allele, f'Expected parse("B*18:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_81():
    result = parse("B*18:81")
    assert result.__class__ is Allele, f'Expected parse("B*18:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_82():
    result = parse("B*18:82")
    assert result.__class__ is Allele, f'Expected parse("B*18:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_83():
    result = parse("B*18:83")
    assert result.__class__ is Allele, f'Expected parse("B*18:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_84():
    result = parse("B*18:84")
    assert result.__class__ is Allele, f'Expected parse("B*18:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_85():
    result = parse("B*18:85")
    assert result.__class__ is Allele, f'Expected parse("B*18:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_86():
    result = parse("B*18:86")
    assert result.__class__ is Allele, f'Expected parse("B*18:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_87():
    result = parse("B*18:87")
    assert result.__class__ is Allele, f'Expected parse("B*18:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_88():
    result = parse("B*18:88")
    assert result.__class__ is Allele, f'Expected parse("B*18:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_89():
    result = parse("B*18:89")
    assert result.__class__ is Allele, f'Expected parse("B*18:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_90():
    result = parse("B*18:90")
    assert result.__class__ is Allele, f'Expected parse("B*18:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_91():
    result = parse("B*18:91")
    assert result.__class__ is Allele, f'Expected parse("B*18:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_92():
    result = parse("B*18:92")
    assert result.__class__ is Allele, f'Expected parse("B*18:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_93():
    result = parse("B*18:93")
    assert result.__class__ is Allele, f'Expected parse("B*18:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_94N():
    result = parse("B*18:94N")
    assert result.__class__ is Allele, f'Expected parse("B*18:94N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:94N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_95():
    result = parse("B*18:95")
    assert result.__class__ is Allele, f'Expected parse("B*18:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_96():
    result = parse("B*18:96")
    assert result.__class__ is Allele, f'Expected parse("B*18:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_97():
    result = parse("B*18:97")
    assert result.__class__ is Allele, f'Expected parse("B*18:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_98_01():
    result = parse("B*18:98:01")
    assert result.__class__ is Allele, f'Expected parse("B*18:98:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:98:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_98_02():
    result = parse("B*18:98:02")
    assert result.__class__ is Allele, f'Expected parse("B*18:98:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*18:98:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_18_99():
    result = parse("B*18:99")
    assert result.__class__ is Allele, f'Expected parse("B*18:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*18:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_01():
    result = parse("B*27:01")
    assert result.__class__ is Allele, f'Expected parse("B*27:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_02_01_01():
    result = parse("B*27:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_02_01_02():
    result = parse("B*27:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_02_01_03():
    result = parse("B*27:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_02_01_04():
    result = parse("B*27:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_02_01_05():
    result = parse("B*27:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_02_02():
    result = parse("B*27:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*27:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_02_03():
    result = parse("B*27:02:03")
    assert result.__class__ is Allele, f'Expected parse("B*27:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_02_04():
    result = parse("B*27:02:04")
    assert result.__class__ is Allele, f'Expected parse("B*27:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_02_05():
    result = parse("B*27:02:05")
    assert result.__class__ is Allele, f'Expected parse("B*27:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_03():
    result = parse("B*27:03")
    assert result.__class__ is Allele, f'Expected parse("B*27:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_04_01():
    result = parse("B*27:04:01")
    assert result.__class__ is Allele, f'Expected parse("B*27:04:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_04_02():
    result = parse("B*27:04:02")
    assert result.__class__ is Allele, f'Expected parse("B*27:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_04_03():
    result = parse("B*27:04:03")
    assert result.__class__ is Allele, f'Expected parse("B*27:04:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_04_04():
    result = parse("B*27:04:04")
    assert result.__class__ is Allele, f'Expected parse("B*27:04:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:04:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_04_05():
    result = parse("B*27:04:05")
    assert result.__class__ is Allele, f'Expected parse("B*27:04:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:04:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_04_06():
    result = parse("B*27:04:06")
    assert result.__class__ is Allele, f'Expected parse("B*27:04:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:04:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_01():
    result = parse("B*27:05:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_02():
    result = parse("B*27:05:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_03():
    result = parse("B*27:05:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_04Q():
    result = parse("B*27:05:02:04Q")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:04Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:04Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_05():
    result = parse("B*27:05:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_06():
    result = parse("B*27:05:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_07():
    result = parse("B*27:05:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_08():
    result = parse("B*27:05:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_09():
    result = parse("B*27:05:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_10():
    result = parse("B*27:05:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_11():
    result = parse("B*27:05:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_12():
    result = parse("B*27:05:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_13():
    result = parse("B*27:05:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_14():
    result = parse("B*27:05:02:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_15():
    result = parse("B*27:05:02:15")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_16():
    result = parse("B*27:05:02:16")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_17():
    result = parse("B*27:05:02:17")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_18():
    result = parse("B*27:05:02:18")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_19():
    result = parse("B*27:05:02:19")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_20():
    result = parse("B*27:05:02:20")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_02_21():
    result = parse("B*27:05:02:21")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:02:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:02:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_03():
    result = parse("B*27:05:03")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_04():
    result = parse("B*27:05:04")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_05():
    result = parse("B*27:05:05")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_06():
    result = parse("B*27:05:06")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_07():
    result = parse("B*27:05:07")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_08():
    result = parse("B*27:05:08")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_09():
    result = parse("B*27:05:09")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_10():
    result = parse("B*27:05:10")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_11():
    result = parse("B*27:05:11")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_12():
    result = parse("B*27:05:12")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_13():
    result = parse("B*27:05:13")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_14():
    result = parse("B*27:05:14")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_15():
    result = parse("B*27:05:15")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_16():
    result = parse("B*27:05:16")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_17():
    result = parse("B*27:05:17")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_18_01():
    result = parse("B*27:05:18:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:18:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:18:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_18_02():
    result = parse("B*27:05:18:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:05:18:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:05:18:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_19():
    result = parse("B*27:05:19")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_20():
    result = parse("B*27:05:20")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_21():
    result = parse("B*27:05:21")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_22():
    result = parse("B*27:05:22")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_23():
    result = parse("B*27:05:23")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_24():
    result = parse("B*27:05:24")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_25():
    result = parse("B*27:05:25")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_26():
    result = parse("B*27:05:26")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_27():
    result = parse("B*27:05:27")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_28():
    result = parse("B*27:05:28")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_29():
    result = parse("B*27:05:29")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_30():
    result = parse("B*27:05:30")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_31():
    result = parse("B*27:05:31")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_32():
    result = parse("B*27:05:32")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_33():
    result = parse("B*27:05:33")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_34():
    result = parse("B*27:05:34")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_35():
    result = parse("B*27:05:35")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_36():
    result = parse("B*27:05:36")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_37():
    result = parse("B*27:05:37")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_38():
    result = parse("B*27:05:38")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_39():
    result = parse("B*27:05:39")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_40():
    result = parse("B*27:05:40")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_41():
    result = parse("B*27:05:41")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_42():
    result = parse("B*27:05:42")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_43():
    result = parse("B*27:05:43")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_44():
    result = parse("B*27:05:44")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_45():
    result = parse("B*27:05:45")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_46():
    result = parse("B*27:05:46")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_47():
    result = parse("B*27:05:47")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_05_48():
    result = parse("B*27:05:48")
    assert result.__class__ is Allele, f'Expected parse("B*27:05:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:05:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_06_01_01():
    result = parse("B*27:06:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:06:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:06:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_06_01_02():
    result = parse("B*27:06:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:06:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:06:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_07_01():
    result = parse("B*27:07:01")
    assert result.__class__ is Allele, f'Expected parse("B*27:07:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_07_02():
    result = parse("B*27:07:02")
    assert result.__class__ is Allele, f'Expected parse("B*27:07:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_07_03():
    result = parse("B*27:07:03")
    assert result.__class__ is Allele, f'Expected parse("B*27:07:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:07:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_07_04():
    result = parse("B*27:07:04")
    assert result.__class__ is Allele, f'Expected parse("B*27:07:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:07:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_07_05():
    result = parse("B*27:07:05")
    assert result.__class__ is Allele, f'Expected parse("B*27:07:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:07:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_07_06():
    result = parse("B*27:07:06")
    assert result.__class__ is Allele, f'Expected parse("B*27:07:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:07:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_08():
    result = parse("B*27:08")
    assert result.__class__ is Allele, f'Expected parse("B*27:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_09():
    result = parse("B*27:09")
    assert result.__class__ is Allele, f'Expected parse("B*27:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_10():
    result = parse("B*27:10")
    assert result.__class__ is Allele, f'Expected parse("B*27:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_100():
    result = parse("B*27:100")
    assert result.__class__ is Allele, f'Expected parse("B*27:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_101():
    result = parse("B*27:101")
    assert result.__class__ is Allele, f'Expected parse("B*27:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_102():
    result = parse("B*27:102")
    assert result.__class__ is Allele, f'Expected parse("B*27:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_103():
    result = parse("B*27:103")
    assert result.__class__ is Allele, f'Expected parse("B*27:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_104():
    result = parse("B*27:104")
    assert result.__class__ is Allele, f'Expected parse("B*27:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_105():
    result = parse("B*27:105")
    assert result.__class__ is Allele, f'Expected parse("B*27:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_106():
    result = parse("B*27:106")
    assert result.__class__ is Allele, f'Expected parse("B*27:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_107():
    result = parse("B*27:107")
    assert result.__class__ is Allele, f'Expected parse("B*27:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_108():
    result = parse("B*27:108")
    assert result.__class__ is Allele, f'Expected parse("B*27:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_109():
    result = parse("B*27:109")
    assert result.__class__ is Allele, f'Expected parse("B*27:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_11():
    result = parse("B*27:11")
    assert result.__class__ is Allele, f'Expected parse("B*27:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_110():
    result = parse("B*27:110")
    assert result.__class__ is Allele, f'Expected parse("B*27:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_111():
    result = parse("B*27:111")
    assert result.__class__ is Allele, f'Expected parse("B*27:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_112():
    result = parse("B*27:112")
    assert result.__class__ is Allele, f'Expected parse("B*27:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_113():
    result = parse("B*27:113")
    assert result.__class__ is Allele, f'Expected parse("B*27:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_114():
    result = parse("B*27:114")
    assert result.__class__ is Allele, f'Expected parse("B*27:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_115():
    result = parse("B*27:115")
    assert result.__class__ is Allele, f'Expected parse("B*27:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_116():
    result = parse("B*27:116")
    assert result.__class__ is Allele, f'Expected parse("B*27:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_117():
    result = parse("B*27:117")
    assert result.__class__ is Allele, f'Expected parse("B*27:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_118():
    result = parse("B*27:118")
    assert result.__class__ is Allele, f'Expected parse("B*27:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_119():
    result = parse("B*27:119")
    assert result.__class__ is Allele, f'Expected parse("B*27:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_120():
    result = parse("B*27:120")
    assert result.__class__ is Allele, f'Expected parse("B*27:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_121():
    result = parse("B*27:121")
    assert result.__class__ is Allele, f'Expected parse("B*27:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_122():
    result = parse("B*27:122")
    assert result.__class__ is Allele, f'Expected parse("B*27:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_123():
    result = parse("B*27:123")
    assert result.__class__ is Allele, f'Expected parse("B*27:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_124():
    result = parse("B*27:124")
    assert result.__class__ is Allele, f'Expected parse("B*27:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_125():
    result = parse("B*27:125")
    assert result.__class__ is Allele, f'Expected parse("B*27:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_126():
    result = parse("B*27:126")
    assert result.__class__ is Allele, f'Expected parse("B*27:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_127():
    result = parse("B*27:127")
    assert result.__class__ is Allele, f'Expected parse("B*27:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_128():
    result = parse("B*27:128")
    assert result.__class__ is Allele, f'Expected parse("B*27:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_129():
    result = parse("B*27:129")
    assert result.__class__ is Allele, f'Expected parse("B*27:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_12_01_01():
    result = parse("B*27:12:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:12:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:12:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_12_01_02():
    result = parse("B*27:12:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:12:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:12:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_12_01_03():
    result = parse("B*27:12:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:12:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:12:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_130():
    result = parse("B*27:130")
    assert result.__class__ is Allele, f'Expected parse("B*27:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_131():
    result = parse("B*27:131")
    assert result.__class__ is Allele, f'Expected parse("B*27:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_132():
    result = parse("B*27:132")
    assert result.__class__ is Allele, f'Expected parse("B*27:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_133():
    result = parse("B*27:133")
    assert result.__class__ is Allele, f'Expected parse("B*27:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_134():
    result = parse("B*27:134")
    assert result.__class__ is Allele, f'Expected parse("B*27:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_135():
    result = parse("B*27:135")
    assert result.__class__ is Allele, f'Expected parse("B*27:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_136():
    result = parse("B*27:136")
    assert result.__class__ is Allele, f'Expected parse("B*27:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_137():
    result = parse("B*27:137")
    assert result.__class__ is Allele, f'Expected parse("B*27:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_138():
    result = parse("B*27:138")
    assert result.__class__ is Allele, f'Expected parse("B*27:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_139():
    result = parse("B*27:139")
    assert result.__class__ is Allele, f'Expected parse("B*27:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_13_01():
    result = parse("B*27:13:01")
    assert result.__class__ is Allele, f'Expected parse("B*27:13:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:13:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_13_02():
    result = parse("B*27:13:02")
    assert result.__class__ is Allele, f'Expected parse("B*27:13:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:13:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_14():
    result = parse("B*27:14")
    assert result.__class__ is Allele, f'Expected parse("B*27:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_140():
    result = parse("B*27:140")
    assert result.__class__ is Allele, f'Expected parse("B*27:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_141():
    result = parse("B*27:141")
    assert result.__class__ is Allele, f'Expected parse("B*27:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_142():
    result = parse("B*27:142")
    assert result.__class__ is Allele, f'Expected parse("B*27:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_143():
    result = parse("B*27:143")
    assert result.__class__ is Allele, f'Expected parse("B*27:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_144_01():
    result = parse("B*27:144:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:144:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:144:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_144_02():
    result = parse("B*27:144:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:144:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:144:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_145():
    result = parse("B*27:145")
    assert result.__class__ is Allele, f'Expected parse("B*27:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_146():
    result = parse("B*27:146")
    assert result.__class__ is Allele, f'Expected parse("B*27:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_147():
    result = parse("B*27:147")
    assert result.__class__ is Allele, f'Expected parse("B*27:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_148():
    result = parse("B*27:148")
    assert result.__class__ is Allele, f'Expected parse("B*27:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_149():
    result = parse("B*27:149")
    assert result.__class__ is Allele, f'Expected parse("B*27:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_15():
    result = parse("B*27:15")
    assert result.__class__ is Allele, f'Expected parse("B*27:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_150():
    result = parse("B*27:150")
    assert result.__class__ is Allele, f'Expected parse("B*27:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_151():
    result = parse("B*27:151")
    assert result.__class__ is Allele, f'Expected parse("B*27:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_152():
    result = parse("B*27:152")
    assert result.__class__ is Allele, f'Expected parse("B*27:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_153():
    result = parse("B*27:153")
    assert result.__class__ is Allele, f'Expected parse("B*27:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_154():
    result = parse("B*27:154")
    assert result.__class__ is Allele, f'Expected parse("B*27:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_155():
    result = parse("B*27:155")
    assert result.__class__ is Allele, f'Expected parse("B*27:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_156():
    result = parse("B*27:156")
    assert result.__class__ is Allele, f'Expected parse("B*27:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_157():
    result = parse("B*27:157")
    assert result.__class__ is Allele, f'Expected parse("B*27:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_158():
    result = parse("B*27:158")
    assert result.__class__ is Allele, f'Expected parse("B*27:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_159():
    result = parse("B*27:159")
    assert result.__class__ is Allele, f'Expected parse("B*27:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_16():
    result = parse("B*27:16")
    assert result.__class__ is Allele, f'Expected parse("B*27:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_160():
    result = parse("B*27:160")
    assert result.__class__ is Allele, f'Expected parse("B*27:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_161():
    result = parse("B*27:161")
    assert result.__class__ is Allele, f'Expected parse("B*27:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_162():
    result = parse("B*27:162")
    assert result.__class__ is Allele, f'Expected parse("B*27:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_163():
    result = parse("B*27:163")
    assert result.__class__ is Allele, f'Expected parse("B*27:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_164():
    result = parse("B*27:164")
    assert result.__class__ is Allele, f'Expected parse("B*27:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_165():
    result = parse("B*27:165")
    assert result.__class__ is Allele, f'Expected parse("B*27:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_166():
    result = parse("B*27:166")
    assert result.__class__ is Allele, f'Expected parse("B*27:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_167():
    result = parse("B*27:167")
    assert result.__class__ is Allele, f'Expected parse("B*27:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_168():
    result = parse("B*27:168")
    assert result.__class__ is Allele, f'Expected parse("B*27:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_169():
    result = parse("B*27:169")
    assert result.__class__ is Allele, f'Expected parse("B*27:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_17():
    result = parse("B*27:17")
    assert result.__class__ is Allele, f'Expected parse("B*27:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_170():
    result = parse("B*27:170")
    assert result.__class__ is Allele, f'Expected parse("B*27:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_171():
    result = parse("B*27:171")
    assert result.__class__ is Allele, f'Expected parse("B*27:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_172():
    result = parse("B*27:172")
    assert result.__class__ is Allele, f'Expected parse("B*27:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_173():
    result = parse("B*27:173")
    assert result.__class__ is Allele, f'Expected parse("B*27:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_174():
    result = parse("B*27:174")
    assert result.__class__ is Allele, f'Expected parse("B*27:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_175():
    result = parse("B*27:175")
    assert result.__class__ is Allele, f'Expected parse("B*27:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_176N():
    result = parse("B*27:176N")
    assert result.__class__ is Allele, f'Expected parse("B*27:176N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:176N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_177():
    result = parse("B*27:177")
    assert result.__class__ is Allele, f'Expected parse("B*27:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_178():
    result = parse("B*27:178")
    assert result.__class__ is Allele, f'Expected parse("B*27:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_179():
    result = parse("B*27:179")
    assert result.__class__ is Allele, f'Expected parse("B*27:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_18():
    result = parse("B*27:18")
    assert result.__class__ is Allele, f'Expected parse("B*27:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_180():
    result = parse("B*27:180")
    assert result.__class__ is Allele, f'Expected parse("B*27:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_181():
    result = parse("B*27:181")
    assert result.__class__ is Allele, f'Expected parse("B*27:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_182():
    result = parse("B*27:182")
    assert result.__class__ is Allele, f'Expected parse("B*27:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_183():
    result = parse("B*27:183")
    assert result.__class__ is Allele, f'Expected parse("B*27:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_184():
    result = parse("B*27:184")
    assert result.__class__ is Allele, f'Expected parse("B*27:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_185Q():
    result = parse("B*27:185Q")
    assert result.__class__ is Allele, f'Expected parse("B*27:185Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:185Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_186():
    result = parse("B*27:186")
    assert result.__class__ is Allele, f'Expected parse("B*27:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_187():
    result = parse("B*27:187")
    assert result.__class__ is Allele, f'Expected parse("B*27:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_188():
    result = parse("B*27:188")
    assert result.__class__ is Allele, f'Expected parse("B*27:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_189():
    result = parse("B*27:189")
    assert result.__class__ is Allele, f'Expected parse("B*27:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_190():
    result = parse("B*27:190")
    assert result.__class__ is Allele, f'Expected parse("B*27:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_191():
    result = parse("B*27:191")
    assert result.__class__ is Allele, f'Expected parse("B*27:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_192():
    result = parse("B*27:192")
    assert result.__class__ is Allele, f'Expected parse("B*27:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_193():
    result = parse("B*27:193")
    assert result.__class__ is Allele, f'Expected parse("B*27:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_194():
    result = parse("B*27:194")
    assert result.__class__ is Allele, f'Expected parse("B*27:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_195():
    result = parse("B*27:195")
    assert result.__class__ is Allele, f'Expected parse("B*27:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_196():
    result = parse("B*27:196")
    assert result.__class__ is Allele, f'Expected parse("B*27:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_197():
    result = parse("B*27:197")
    assert result.__class__ is Allele, f'Expected parse("B*27:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_198():
    result = parse("B*27:198")
    assert result.__class__ is Allele, f'Expected parse("B*27:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_199():
    result = parse("B*27:199")
    assert result.__class__ is Allele, f'Expected parse("B*27:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_19_01_01():
    result = parse("B*27:19:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:19:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:19:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_19_01_02():
    result = parse("B*27:19:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*27:19:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*27:19:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_20():
    result = parse("B*27:20")
    assert result.__class__ is Allele, f'Expected parse("B*27:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_200():
    result = parse("B*27:200")
    assert result.__class__ is Allele, f'Expected parse("B*27:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_201():
    result = parse("B*27:201")
    assert result.__class__ is Allele, f'Expected parse("B*27:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_202():
    result = parse("B*27:202")
    assert result.__class__ is Allele, f'Expected parse("B*27:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_203():
    result = parse("B*27:203")
    assert result.__class__ is Allele, f'Expected parse("B*27:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_204():
    result = parse("B*27:204")
    assert result.__class__ is Allele, f'Expected parse("B*27:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_205():
    result = parse("B*27:205")
    assert result.__class__ is Allele, f'Expected parse("B*27:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_206():
    result = parse("B*27:206")
    assert result.__class__ is Allele, f'Expected parse("B*27:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_207():
    result = parse("B*27:207")
    assert result.__class__ is Allele, f'Expected parse("B*27:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_208():
    result = parse("B*27:208")
    assert result.__class__ is Allele, f'Expected parse("B*27:208") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_209():
    result = parse("B*27:209")
    assert result.__class__ is Allele, f'Expected parse("B*27:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_210():
    result = parse("B*27:210")
    assert result.__class__ is Allele, f'Expected parse("B*27:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_211():
    result = parse("B*27:211")
    assert result.__class__ is Allele, f'Expected parse("B*27:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_212N():
    result = parse("B*27:212N")
    assert result.__class__ is Allele, f'Expected parse("B*27:212N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:212N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_213():
    result = parse("B*27:213")
    assert result.__class__ is Allele, f'Expected parse("B*27:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_214():
    result = parse("B*27:214")
    assert result.__class__ is Allele, f'Expected parse("B*27:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_215N():
    result = parse("B*27:215N")
    assert result.__class__ is Allele, f'Expected parse("B*27:215N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:215N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_216():
    result = parse("B*27:216")
    assert result.__class__ is Allele, f'Expected parse("B*27:216") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_217():
    result = parse("B*27:217")
    assert result.__class__ is Allele, f'Expected parse("B*27:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_218():
    result = parse("B*27:218")
    assert result.__class__ is Allele, f'Expected parse("B*27:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_219():
    result = parse("B*27:219")
    assert result.__class__ is Allele, f'Expected parse("B*27:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_21_01():
    result = parse("B*27:21:01")
    assert result.__class__ is Allele, f'Expected parse("B*27:21:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:21:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_21_02():
    result = parse("B*27:21:02")
    assert result.__class__ is Allele, f'Expected parse("B*27:21:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:21:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_220():
    result = parse("B*27:220")
    assert result.__class__ is Allele, f'Expected parse("B*27:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_221():
    result = parse("B*27:221")
    assert result.__class__ is Allele, f'Expected parse("B*27:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_222():
    result = parse("B*27:222")
    assert result.__class__ is Allele, f'Expected parse("B*27:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_223N():
    result = parse("B*27:223N")
    assert result.__class__ is Allele, f'Expected parse("B*27:223N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:223N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_224():
    result = parse("B*27:224")
    assert result.__class__ is Allele, f'Expected parse("B*27:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_225N():
    result = parse("B*27:225N")
    assert result.__class__ is Allele, f'Expected parse("B*27:225N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:225N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_226():
    result = parse("B*27:226")
    assert result.__class__ is Allele, f'Expected parse("B*27:226") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_227():
    result = parse("B*27:227")
    assert result.__class__ is Allele, f'Expected parse("B*27:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_228():
    result = parse("B*27:228")
    assert result.__class__ is Allele, f'Expected parse("B*27:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_229():
    result = parse("B*27:229")
    assert result.__class__ is Allele, f'Expected parse("B*27:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_23():
    result = parse("B*27:23")
    assert result.__class__ is Allele, f'Expected parse("B*27:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_230():
    result = parse("B*27:230")
    assert result.__class__ is Allele, f'Expected parse("B*27:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_231():
    result = parse("B*27:231")
    assert result.__class__ is Allele, f'Expected parse("B*27:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_232():
    result = parse("B*27:232")
    assert result.__class__ is Allele, f'Expected parse("B*27:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_24():
    result = parse("B*27:24")
    assert result.__class__ is Allele, f'Expected parse("B*27:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_25():
    result = parse("B*27:25")
    assert result.__class__ is Allele, f'Expected parse("B*27:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_26():
    result = parse("B*27:26")
    assert result.__class__ is Allele, f'Expected parse("B*27:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_27():
    result = parse("B*27:27")
    assert result.__class__ is Allele, f'Expected parse("B*27:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_28():
    result = parse("B*27:28")
    assert result.__class__ is Allele, f'Expected parse("B*27:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_29():
    result = parse("B*27:29")
    assert result.__class__ is Allele, f'Expected parse("B*27:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_30():
    result = parse("B*27:30")
    assert result.__class__ is Allele, f'Expected parse("B*27:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_31():
    result = parse("B*27:31")
    assert result.__class__ is Allele, f'Expected parse("B*27:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_32():
    result = parse("B*27:32")
    assert result.__class__ is Allele, f'Expected parse("B*27:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_33():
    result = parse("B*27:33")
    assert result.__class__ is Allele, f'Expected parse("B*27:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_34():
    result = parse("B*27:34")
    assert result.__class__ is Allele, f'Expected parse("B*27:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_35():
    result = parse("B*27:35")
    assert result.__class__ is Allele, f'Expected parse("B*27:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_36():
    result = parse("B*27:36")
    assert result.__class__ is Allele, f'Expected parse("B*27:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_37():
    result = parse("B*27:37")
    assert result.__class__ is Allele, f'Expected parse("B*27:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_38():
    result = parse("B*27:38")
    assert result.__class__ is Allele, f'Expected parse("B*27:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_39():
    result = parse("B*27:39")
    assert result.__class__ is Allele, f'Expected parse("B*27:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_40():
    result = parse("B*27:40")
    assert result.__class__ is Allele, f'Expected parse("B*27:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_41():
    result = parse("B*27:41")
    assert result.__class__ is Allele, f'Expected parse("B*27:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_42():
    result = parse("B*27:42")
    assert result.__class__ is Allele, f'Expected parse("B*27:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_43():
    result = parse("B*27:43")
    assert result.__class__ is Allele, f'Expected parse("B*27:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_44():
    result = parse("B*27:44")
    assert result.__class__ is Allele, f'Expected parse("B*27:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_45():
    result = parse("B*27:45")
    assert result.__class__ is Allele, f'Expected parse("B*27:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_46():
    result = parse("B*27:46")
    assert result.__class__ is Allele, f'Expected parse("B*27:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_47():
    result = parse("B*27:47")
    assert result.__class__ is Allele, f'Expected parse("B*27:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_48():
    result = parse("B*27:48")
    assert result.__class__ is Allele, f'Expected parse("B*27:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_49():
    result = parse("B*27:49")
    assert result.__class__ is Allele, f'Expected parse("B*27:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_50_01():
    result = parse("B*27:50:01")
    assert result.__class__ is Allele, f'Expected parse("B*27:50:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:50:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_50_02():
    result = parse("B*27:50:02")
    assert result.__class__ is Allele, f'Expected parse("B*27:50:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:50:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_51():
    result = parse("B*27:51")
    assert result.__class__ is Allele, f'Expected parse("B*27:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_52():
    result = parse("B*27:52")
    assert result.__class__ is Allele, f'Expected parse("B*27:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_53():
    result = parse("B*27:53")
    assert result.__class__ is Allele, f'Expected parse("B*27:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_54():
    result = parse("B*27:54")
    assert result.__class__ is Allele, f'Expected parse("B*27:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_55():
    result = parse("B*27:55")
    assert result.__class__ is Allele, f'Expected parse("B*27:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_56():
    result = parse("B*27:56")
    assert result.__class__ is Allele, f'Expected parse("B*27:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_57():
    result = parse("B*27:57")
    assert result.__class__ is Allele, f'Expected parse("B*27:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_58():
    result = parse("B*27:58")
    assert result.__class__ is Allele, f'Expected parse("B*27:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_59N():
    result = parse("B*27:59N")
    assert result.__class__ is Allele, f'Expected parse("B*27:59N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:59N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_60():
    result = parse("B*27:60")
    assert result.__class__ is Allele, f'Expected parse("B*27:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_61():
    result = parse("B*27:61")
    assert result.__class__ is Allele, f'Expected parse("B*27:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_62():
    result = parse("B*27:62")
    assert result.__class__ is Allele, f'Expected parse("B*27:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_63():
    result = parse("B*27:63")
    assert result.__class__ is Allele, f'Expected parse("B*27:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_64N():
    result = parse("B*27:64N")
    assert result.__class__ is Allele, f'Expected parse("B*27:64N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:64N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_65N():
    result = parse("B*27:65N")
    assert result.__class__ is Allele, f'Expected parse("B*27:65N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:65N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_66N():
    result = parse("B*27:66N")
    assert result.__class__ is Allele, f'Expected parse("B*27:66N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:66N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_67():
    result = parse("B*27:67")
    assert result.__class__ is Allele, f'Expected parse("B*27:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_68():
    result = parse("B*27:68")
    assert result.__class__ is Allele, f'Expected parse("B*27:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_69():
    result = parse("B*27:69")
    assert result.__class__ is Allele, f'Expected parse("B*27:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_70():
    result = parse("B*27:70")
    assert result.__class__ is Allele, f'Expected parse("B*27:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_71():
    result = parse("B*27:71")
    assert result.__class__ is Allele, f'Expected parse("B*27:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_72():
    result = parse("B*27:72")
    assert result.__class__ is Allele, f'Expected parse("B*27:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_73():
    result = parse("B*27:73")
    assert result.__class__ is Allele, f'Expected parse("B*27:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_74():
    result = parse("B*27:74")
    assert result.__class__ is Allele, f'Expected parse("B*27:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_75():
    result = parse("B*27:75")
    assert result.__class__ is Allele, f'Expected parse("B*27:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_76():
    result = parse("B*27:76")
    assert result.__class__ is Allele, f'Expected parse("B*27:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_77():
    result = parse("B*27:77")
    assert result.__class__ is Allele, f'Expected parse("B*27:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_78():
    result = parse("B*27:78")
    assert result.__class__ is Allele, f'Expected parse("B*27:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_79():
    result = parse("B*27:79")
    assert result.__class__ is Allele, f'Expected parse("B*27:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_80():
    result = parse("B*27:80")
    assert result.__class__ is Allele, f'Expected parse("B*27:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_81():
    result = parse("B*27:81")
    assert result.__class__ is Allele, f'Expected parse("B*27:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_82():
    result = parse("B*27:82")
    assert result.__class__ is Allele, f'Expected parse("B*27:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_83():
    result = parse("B*27:83")
    assert result.__class__ is Allele, f'Expected parse("B*27:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_84():
    result = parse("B*27:84")
    assert result.__class__ is Allele, f'Expected parse("B*27:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_85():
    result = parse("B*27:85")
    assert result.__class__ is Allele, f'Expected parse("B*27:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_86():
    result = parse("B*27:86")
    assert result.__class__ is Allele, f'Expected parse("B*27:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_87():
    result = parse("B*27:87")
    assert result.__class__ is Allele, f'Expected parse("B*27:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_88():
    result = parse("B*27:88")
    assert result.__class__ is Allele, f'Expected parse("B*27:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_89():
    result = parse("B*27:89")
    assert result.__class__ is Allele, f'Expected parse("B*27:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_90_01():
    result = parse("B*27:90:01")
    assert result.__class__ is Allele, f'Expected parse("B*27:90:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:90:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_90_02():
    result = parse("B*27:90:02")
    assert result.__class__ is Allele, f'Expected parse("B*27:90:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:90:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_90_03():
    result = parse("B*27:90:03")
    assert result.__class__ is Allele, f'Expected parse("B*27:90:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:90:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_90_04():
    result = parse("B*27:90:04")
    assert result.__class__ is Allele, f'Expected parse("B*27:90:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:90:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_91():
    result = parse("B*27:91")
    assert result.__class__ is Allele, f'Expected parse("B*27:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_92():
    result = parse("B*27:92")
    assert result.__class__ is Allele, f'Expected parse("B*27:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_93():
    result = parse("B*27:93")
    assert result.__class__ is Allele, f'Expected parse("B*27:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_94N():
    result = parse("B*27:94N")
    assert result.__class__ is Allele, f'Expected parse("B*27:94N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:94N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_95():
    result = parse("B*27:95")
    assert result.__class__ is Allele, f'Expected parse("B*27:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_96_01():
    result = parse("B*27:96:01")
    assert result.__class__ is Allele, f'Expected parse("B*27:96:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:96:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_96_02():
    result = parse("B*27:96:02")
    assert result.__class__ is Allele, f'Expected parse("B*27:96:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*27:96:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_97():
    result = parse("B*27:97")
    assert result.__class__ is Allele, f'Expected parse("B*27:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_98():
    result = parse("B*27:98")
    assert result.__class__ is Allele, f'Expected parse("B*27:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_27_99():
    result = parse("B*27:99")
    assert result.__class__ is Allele, f'Expected parse("B*27:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*27:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_01():
    result = parse("B*35:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_02():
    result = parse("B*35:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_03():
    result = parse("B*35:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_04():
    result = parse("B*35:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_05():
    result = parse("B*35:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_06():
    result = parse("B*35:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_07():
    result = parse("B*35:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_08():
    result = parse("B*35:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_09():
    result = parse("B*35:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_10():
    result = parse("B*35:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_11():
    result = parse("B*35:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_12():
    result = parse("B*35:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_13():
    result = parse("B*35:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_14():
    result = parse("B*35:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_15():
    result = parse("B*35:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_16():
    result = parse("B*35:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_17():
    result = parse("B*35:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_18():
    result = parse("B*35:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_19():
    result = parse("B*35:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_20():
    result = parse("B*35:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_21():
    result = parse("B*35:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_22():
    result = parse("B*35:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_23():
    result = parse("B*35:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_24():
    result = parse("B*35:01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_25():
    result = parse("B*35:01:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_26():
    result = parse("B*35:01:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_27():
    result = parse("B*35:01:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_28():
    result = parse("B*35:01:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_29():
    result = parse("B*35:01:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_30():
    result = parse("B*35:01:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_31():
    result = parse("B*35:01:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_32():
    result = parse("B*35:01:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_33():
    result = parse("B*35:01:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_34():
    result = parse("B*35:01:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_35():
    result = parse("B*35:01:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_36():
    result = parse("B*35:01:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_37():
    result = parse("B*35:01:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_38():
    result = parse("B*35:01:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_39():
    result = parse("B*35:01:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_40():
    result = parse("B*35:01:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_41():
    result = parse("B*35:01:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_42():
    result = parse("B*35:01:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_43():
    result = parse("B*35:01:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_44():
    result = parse("B*35:01:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_45():
    result = parse("B*35:01:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:45") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_46():
    result = parse("B*35:01:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:46") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_47():
    result = parse("B*35:01:01:47")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:47") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_48():
    result = parse("B*35:01:01:48")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:48") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:48") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_49():
    result = parse("B*35:01:01:49")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:49") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:49") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_01_50():
    result = parse("B*35:01:01:50")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:01:01:50") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:01:01:50") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_02():
    result = parse("B*35:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_03():
    result = parse("B*35:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_04():
    result = parse("B*35:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_05():
    result = parse("B*35:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_06():
    result = parse("B*35:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_07():
    result = parse("B*35:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_08():
    result = parse("B*35:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_09():
    result = parse("B*35:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_10():
    result = parse("B*35:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_11():
    result = parse("B*35:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_12():
    result = parse("B*35:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_13():
    result = parse("B*35:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_14():
    result = parse("B*35:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_15():
    result = parse("B*35:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_16():
    result = parse("B*35:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_17():
    result = parse("B*35:01:17")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_18():
    result = parse("B*35:01:18")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_19():
    result = parse("B*35:01:19")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_20():
    result = parse("B*35:01:20")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_21():
    result = parse("B*35:01:21")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_22():
    result = parse("B*35:01:22")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_23():
    result = parse("B*35:01:23")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_24():
    result = parse("B*35:01:24")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_25():
    result = parse("B*35:01:25")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_26():
    result = parse("B*35:01:26")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_27():
    result = parse("B*35:01:27")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_28():
    result = parse("B*35:01:28")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_29():
    result = parse("B*35:01:29")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_30():
    result = parse("B*35:01:30")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_31():
    result = parse("B*35:01:31")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_32():
    result = parse("B*35:01:32")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_33():
    result = parse("B*35:01:33")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_34():
    result = parse("B*35:01:34")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_35():
    result = parse("B*35:01:35")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_36():
    result = parse("B*35:01:36")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_37():
    result = parse("B*35:01:37")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_38():
    result = parse("B*35:01:38")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_39():
    result = parse("B*35:01:39")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_40():
    result = parse("B*35:01:40")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_41():
    result = parse("B*35:01:41")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_42():
    result = parse("B*35:01:42")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_43():
    result = parse("B*35:01:43")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_44():
    result = parse("B*35:01:44")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_45():
    result = parse("B*35:01:45")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_46():
    result = parse("B*35:01:46")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_47():
    result = parse("B*35:01:47")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_48():
    result = parse("B*35:01:48")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_49():
    result = parse("B*35:01:49")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_50():
    result = parse("B*35:01:50")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_51():
    result = parse("B*35:01:51")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_52():
    result = parse("B*35:01:52")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_53():
    result = parse("B*35:01:53")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_54():
    result = parse("B*35:01:54")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_55():
    result = parse("B*35:01:55")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_56():
    result = parse("B*35:01:56")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_57():
    result = parse("B*35:01:57")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_58():
    result = parse("B*35:01:58")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_59():
    result = parse("B*35:01:59")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_60():
    result = parse("B*35:01:60")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_61():
    result = parse("B*35:01:61")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_62():
    result = parse("B*35:01:62")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_63():
    result = parse("B*35:01:63")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_64():
    result = parse("B*35:01:64")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_65():
    result = parse("B*35:01:65")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_01_66():
    result = parse("B*35:01:66")
    assert result.__class__ is Allele, f'Expected parse("B*35:01:66") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:01:66") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_01_01():
    result = parse("B*35:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_01_02():
    result = parse("B*35:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_01_03():
    result = parse("B*35:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_01_04():
    result = parse("B*35:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_01_05():
    result = parse("B*35:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_02():
    result = parse("B*35:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_03():
    result = parse("B*35:02:03")
    assert result.__class__ is Allele, f'Expected parse("B*35:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_04():
    result = parse("B*35:02:04")
    assert result.__class__ is Allele, f'Expected parse("B*35:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_05():
    result = parse("B*35:02:05")
    assert result.__class__ is Allele, f'Expected parse("B*35:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_06():
    result = parse("B*35:02:06")
    assert result.__class__ is Allele, f'Expected parse("B*35:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_07():
    result = parse("B*35:02:07")
    assert result.__class__ is Allele, f'Expected parse("B*35:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_08():
    result = parse("B*35:02:08")
    assert result.__class__ is Allele, f'Expected parse("B*35:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_09():
    result = parse("B*35:02:09")
    assert result.__class__ is Allele, f'Expected parse("B*35:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_10():
    result = parse("B*35:02:10")
    assert result.__class__ is Allele, f'Expected parse("B*35:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_11():
    result = parse("B*35:02:11")
    assert result.__class__ is Allele, f'Expected parse("B*35:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_12():
    result = parse("B*35:02:12")
    assert result.__class__ is Allele, f'Expected parse("B*35:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_13():
    result = parse("B*35:02:13")
    assert result.__class__ is Allele, f'Expected parse("B*35:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_14():
    result = parse("B*35:02:14")
    assert result.__class__ is Allele, f'Expected parse("B*35:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_15():
    result = parse("B*35:02:15")
    assert result.__class__ is Allele, f'Expected parse("B*35:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_02_16():
    result = parse("B*35:02:16")
    assert result.__class__ is Allele, f'Expected parse("B*35:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_01():
    result = parse("B*35:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_02():
    result = parse("B*35:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_03():
    result = parse("B*35:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_04():
    result = parse("B*35:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_05():
    result = parse("B*35:03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_06():
    result = parse("B*35:03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_07():
    result = parse("B*35:03:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_08():
    result = parse("B*35:03:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_09():
    result = parse("B*35:03:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_10():
    result = parse("B*35:03:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_11():
    result = parse("B*35:03:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_12():
    result = parse("B*35:03:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_13():
    result = parse("B*35:03:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_14():
    result = parse("B*35:03:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_15():
    result = parse("B*35:03:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_16():
    result = parse("B*35:03:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_01_17():
    result = parse("B*35:03:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:03:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:03:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_02():
    result = parse("B*35:03:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_03():
    result = parse("B*35:03:03")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_04():
    result = parse("B*35:03:04")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_05():
    result = parse("B*35:03:05")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_06():
    result = parse("B*35:03:06")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_07():
    result = parse("B*35:03:07")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_08():
    result = parse("B*35:03:08")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_09():
    result = parse("B*35:03:09")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_10():
    result = parse("B*35:03:10")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_11():
    result = parse("B*35:03:11")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_12():
    result = parse("B*35:03:12")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_13():
    result = parse("B*35:03:13")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_14():
    result = parse("B*35:03:14")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_15():
    result = parse("B*35:03:15")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_16():
    result = parse("B*35:03:16")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_17():
    result = parse("B*35:03:17")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_18():
    result = parse("B*35:03:18")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_19():
    result = parse("B*35:03:19")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_20():
    result = parse("B*35:03:20")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_21():
    result = parse("B*35:03:21")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_22():
    result = parse("B*35:03:22")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_23():
    result = parse("B*35:03:23")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_24():
    result = parse("B*35:03:24")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_25():
    result = parse("B*35:03:25")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_26():
    result = parse("B*35:03:26")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_27():
    result = parse("B*35:03:27")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_28():
    result = parse("B*35:03:28")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_29():
    result = parse("B*35:03:29")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_30():
    result = parse("B*35:03:30")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_03_31():
    result = parse("B*35:03:31")
    assert result.__class__ is Allele, f'Expected parse("B*35:03:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:03:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_04_01_01():
    result = parse("B*35:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_04_01_02():
    result = parse("B*35:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_04_02():
    result = parse("B*35:04:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_04_03():
    result = parse("B*35:04:03")
    assert result.__class__ is Allele, f'Expected parse("B*35:04:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_05_01_01():
    result = parse("B*35:05:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:05:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:05:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_05_01_02():
    result = parse("B*35:05:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:05:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:05:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_05_01_03():
    result = parse("B*35:05:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:05:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:05:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_05_01_04():
    result = parse("B*35:05:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:05:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:05:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_05_02():
    result = parse("B*35:05:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:05:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_05_03():
    result = parse("B*35:05:03")
    assert result.__class__ is Allele, f'Expected parse("B*35:05:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:05:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_05_04():
    result = parse("B*35:05:04")
    assert result.__class__ is Allele, f'Expected parse("B*35:05:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:05:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_06():
    result = parse("B*35:06")
    assert result.__class__ is Allele, f'Expected parse("B*35:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_07():
    result = parse("B*35:07")
    assert result.__class__ is Allele, f'Expected parse("B*35:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_01_01():
    result = parse("B*35:08:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:08:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:08:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_01_02():
    result = parse("B*35:08:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:08:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:08:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_01_03():
    result = parse("B*35:08:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:08:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:08:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_01_04():
    result = parse("B*35:08:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:08:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:08:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_01_05():
    result = parse("B*35:08:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:08:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:08:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_01_06():
    result = parse("B*35:08:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:08:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:08:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_01_07():
    result = parse("B*35:08:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:08:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:08:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_01_08():
    result = parse("B*35:08:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:08:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:08:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_02():
    result = parse("B*35:08:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:08:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:08:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_03():
    result = parse("B*35:08:03")
    assert result.__class__ is Allele, f'Expected parse("B*35:08:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:08:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_04():
    result = parse("B*35:08:04")
    assert result.__class__ is Allele, f'Expected parse("B*35:08:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:08:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_05():
    result = parse("B*35:08:05")
    assert result.__class__ is Allele, f'Expected parse("B*35:08:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:08:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_06():
    result = parse("B*35:08:06")
    assert result.__class__ is Allele, f'Expected parse("B*35:08:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:08:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_07():
    result = parse("B*35:08:07")
    assert result.__class__ is Allele, f'Expected parse("B*35:08:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:08:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_08():
    result = parse("B*35:08:08")
    assert result.__class__ is Allele, f'Expected parse("B*35:08:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:08:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_09():
    result = parse("B*35:08:09")
    assert result.__class__ is Allele, f'Expected parse("B*35:08:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:08:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_10():
    result = parse("B*35:08:10")
    assert result.__class__ is Allele, f'Expected parse("B*35:08:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:08:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_11():
    result = parse("B*35:08:11")
    assert result.__class__ is Allele, f'Expected parse("B*35:08:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:08:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_12():
    result = parse("B*35:08:12")
    assert result.__class__ is Allele, f'Expected parse("B*35:08:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:08:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_08_13():
    result = parse("B*35:08:13")
    assert result.__class__ is Allele, f'Expected parse("B*35:08:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:08:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_09_01():
    result = parse("B*35:09:01")
    assert result.__class__ is Allele, f'Expected parse("B*35:09:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:09:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_09_02():
    result = parse("B*35:09:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:09:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:09:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_09_03():
    result = parse("B*35:09:03")
    assert result.__class__ is Allele, f'Expected parse("B*35:09:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:09:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_10():
    result = parse("B*35:10")
    assert result.__class__ is Allele, f'Expected parse("B*35:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_100():
    result = parse("B*35:100")
    assert result.__class__ is Allele, f'Expected parse("B*35:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_101_01():
    result = parse("B*35:101:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:101:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:101:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_101_02():
    result = parse("B*35:101:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:101:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:101:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_102():
    result = parse("B*35:102")
    assert result.__class__ is Allele, f'Expected parse("B*35:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_103():
    result = parse("B*35:103")
    assert result.__class__ is Allele, f'Expected parse("B*35:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_104():
    result = parse("B*35:104")
    assert result.__class__ is Allele, f'Expected parse("B*35:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_105():
    result = parse("B*35:105")
    assert result.__class__ is Allele, f'Expected parse("B*35:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_106():
    result = parse("B*35:106")
    assert result.__class__ is Allele, f'Expected parse("B*35:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_107():
    result = parse("B*35:107")
    assert result.__class__ is Allele, f'Expected parse("B*35:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_108_01():
    result = parse("B*35:108:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:108:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:108:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_108_02():
    result = parse("B*35:108:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:108:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:108:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_109():
    result = parse("B*35:109")
    assert result.__class__ is Allele, f'Expected parse("B*35:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_110():
    result = parse("B*35:110")
    assert result.__class__ is Allele, f'Expected parse("B*35:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_111():
    result = parse("B*35:111")
    assert result.__class__ is Allele, f'Expected parse("B*35:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_112():
    result = parse("B*35:112")
    assert result.__class__ is Allele, f'Expected parse("B*35:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_113():
    result = parse("B*35:113")
    assert result.__class__ is Allele, f'Expected parse("B*35:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_114():
    result = parse("B*35:114")
    assert result.__class__ is Allele, f'Expected parse("B*35:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_115():
    result = parse("B*35:115")
    assert result.__class__ is Allele, f'Expected parse("B*35:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_116():
    result = parse("B*35:116")
    assert result.__class__ is Allele, f'Expected parse("B*35:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_117():
    result = parse("B*35:117")
    assert result.__class__ is Allele, f'Expected parse("B*35:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_118():
    result = parse("B*35:118")
    assert result.__class__ is Allele, f'Expected parse("B*35:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_119():
    result = parse("B*35:119")
    assert result.__class__ is Allele, f'Expected parse("B*35:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_11_01():
    result = parse("B*35:11:01")
    assert result.__class__ is Allele, f'Expected parse("B*35:11:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:11:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_11_02():
    result = parse("B*35:11:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:11:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:11:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_11_03():
    result = parse("B*35:11:03")
    assert result.__class__ is Allele, f'Expected parse("B*35:11:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:11:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_120():
    result = parse("B*35:120")
    assert result.__class__ is Allele, f'Expected parse("B*35:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_121():
    result = parse("B*35:121")
    assert result.__class__ is Allele, f'Expected parse("B*35:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_122():
    result = parse("B*35:122")
    assert result.__class__ is Allele, f'Expected parse("B*35:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_123():
    result = parse("B*35:123")
    assert result.__class__ is Allele, f'Expected parse("B*35:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_124():
    result = parse("B*35:124")
    assert result.__class__ is Allele, f'Expected parse("B*35:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_125():
    result = parse("B*35:125")
    assert result.__class__ is Allele, f'Expected parse("B*35:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_126():
    result = parse("B*35:126")
    assert result.__class__ is Allele, f'Expected parse("B*35:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_127():
    result = parse("B*35:127")
    assert result.__class__ is Allele, f'Expected parse("B*35:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_128():
    result = parse("B*35:128")
    assert result.__class__ is Allele, f'Expected parse("B*35:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_129N():
    result = parse("B*35:129N")
    assert result.__class__ is Allele, f'Expected parse("B*35:129N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:129N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_12_01_01():
    result = parse("B*35:12:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:12:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:12:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_12_01_02():
    result = parse("B*35:12:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:12:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:12:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_12_02():
    result = parse("B*35:12:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:12:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:12:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_12_03():
    result = parse("B*35:12:03")
    assert result.__class__ is Allele, f'Expected parse("B*35:12:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:12:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_12_04():
    result = parse("B*35:12:04")
    assert result.__class__ is Allele, f'Expected parse("B*35:12:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:12:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_13():
    result = parse("B*35:13")
    assert result.__class__ is Allele, f'Expected parse("B*35:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_130N():
    result = parse("B*35:130N")
    assert result.__class__ is Allele, f'Expected parse("B*35:130N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:130N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_131_01():
    result = parse("B*35:131:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:131:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:131:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_131_02():
    result = parse("B*35:131:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:131:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:131:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_132():
    result = parse("B*35:132")
    assert result.__class__ is Allele, f'Expected parse("B*35:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_133():
    result = parse("B*35:133")
    assert result.__class__ is Allele, f'Expected parse("B*35:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_134N():
    result = parse("B*35:134N")
    assert result.__class__ is Allele, f'Expected parse("B*35:134N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:134N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_135():
    result = parse("B*35:135")
    assert result.__class__ is Allele, f'Expected parse("B*35:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_136():
    result = parse("B*35:136")
    assert result.__class__ is Allele, f'Expected parse("B*35:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_137():
    result = parse("B*35:137")
    assert result.__class__ is Allele, f'Expected parse("B*35:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_138():
    result = parse("B*35:138")
    assert result.__class__ is Allele, f'Expected parse("B*35:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_139():
    result = parse("B*35:139")
    assert result.__class__ is Allele, f'Expected parse("B*35:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_140():
    result = parse("B*35:140")
    assert result.__class__ is Allele, f'Expected parse("B*35:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_141():
    result = parse("B*35:141")
    assert result.__class__ is Allele, f'Expected parse("B*35:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_142():
    result = parse("B*35:142")
    assert result.__class__ is Allele, f'Expected parse("B*35:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_143():
    result = parse("B*35:143")
    assert result.__class__ is Allele, f'Expected parse("B*35:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_144():
    result = parse("B*35:144")
    assert result.__class__ is Allele, f'Expected parse("B*35:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_145N():
    result = parse("B*35:145N")
    assert result.__class__ is Allele, f'Expected parse("B*35:145N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:145N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_146():
    result = parse("B*35:146")
    assert result.__class__ is Allele, f'Expected parse("B*35:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_147():
    result = parse("B*35:147")
    assert result.__class__ is Allele, f'Expected parse("B*35:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_148():
    result = parse("B*35:148")
    assert result.__class__ is Allele, f'Expected parse("B*35:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_149():
    result = parse("B*35:149")
    assert result.__class__ is Allele, f'Expected parse("B*35:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_14_01():
    result = parse("B*35:14:01")
    assert result.__class__ is Allele, f'Expected parse("B*35:14:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:14:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_14_02():
    result = parse("B*35:14:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:14:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:14:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_14_03():
    result = parse("B*35:14:03")
    assert result.__class__ is Allele, f'Expected parse("B*35:14:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:14:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_150_01():
    result = parse("B*35:150:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:150:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:150:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_150_02():
    result = parse("B*35:150:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:150:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:150:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_151_01():
    result = parse("B*35:151:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:151:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:151:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_151_02():
    result = parse("B*35:151:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:151:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:151:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_152():
    result = parse("B*35:152")
    assert result.__class__ is Allele, f'Expected parse("B*35:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_153():
    result = parse("B*35:153")
    assert result.__class__ is Allele, f'Expected parse("B*35:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_154():
    result = parse("B*35:154")
    assert result.__class__ is Allele, f'Expected parse("B*35:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_155():
    result = parse("B*35:155")
    assert result.__class__ is Allele, f'Expected parse("B*35:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_156():
    result = parse("B*35:156")
    assert result.__class__ is Allele, f'Expected parse("B*35:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_157():
    result = parse("B*35:157")
    assert result.__class__ is Allele, f'Expected parse("B*35:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_158():
    result = parse("B*35:158")
    assert result.__class__ is Allele, f'Expected parse("B*35:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_159():
    result = parse("B*35:159")
    assert result.__class__ is Allele, f'Expected parse("B*35:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_15_01():
    result = parse("B*35:15:01")
    assert result.__class__ is Allele, f'Expected parse("B*35:15:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:15:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_15_02():
    result = parse("B*35:15:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:15:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:15:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_16():
    result = parse("B*35:16")
    assert result.__class__ is Allele, f'Expected parse("B*35:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_160():
    result = parse("B*35:160")
    assert result.__class__ is Allele, f'Expected parse("B*35:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_161():
    result = parse("B*35:161")
    assert result.__class__ is Allele, f'Expected parse("B*35:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_162():
    result = parse("B*35:162")
    assert result.__class__ is Allele, f'Expected parse("B*35:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_163():
    result = parse("B*35:163")
    assert result.__class__ is Allele, f'Expected parse("B*35:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_164():
    result = parse("B*35:164")
    assert result.__class__ is Allele, f'Expected parse("B*35:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_165N():
    result = parse("B*35:165N")
    assert result.__class__ is Allele, f'Expected parse("B*35:165N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:165N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_166():
    result = parse("B*35:166")
    assert result.__class__ is Allele, f'Expected parse("B*35:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_167():
    result = parse("B*35:167")
    assert result.__class__ is Allele, f'Expected parse("B*35:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_168():
    result = parse("B*35:168")
    assert result.__class__ is Allele, f'Expected parse("B*35:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_169():
    result = parse("B*35:169")
    assert result.__class__ is Allele, f'Expected parse("B*35:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_170():
    result = parse("B*35:170")
    assert result.__class__ is Allele, f'Expected parse("B*35:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_171():
    result = parse("B*35:171")
    assert result.__class__ is Allele, f'Expected parse("B*35:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_172():
    result = parse("B*35:172")
    assert result.__class__ is Allele, f'Expected parse("B*35:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_173_01N():
    result = parse("B*35:173:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:173:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:173:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_173_02N():
    result = parse("B*35:173:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:173:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:173:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_174():
    result = parse("B*35:174")
    assert result.__class__ is Allele, f'Expected parse("B*35:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_175():
    result = parse("B*35:175")
    assert result.__class__ is Allele, f'Expected parse("B*35:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_176():
    result = parse("B*35:176")
    assert result.__class__ is Allele, f'Expected parse("B*35:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_177():
    result = parse("B*35:177")
    assert result.__class__ is Allele, f'Expected parse("B*35:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_178():
    result = parse("B*35:178")
    assert result.__class__ is Allele, f'Expected parse("B*35:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_179():
    result = parse("B*35:179")
    assert result.__class__ is Allele, f'Expected parse("B*35:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_17_01():
    result = parse("B*35:17:01")
    assert result.__class__ is Allele, f'Expected parse("B*35:17:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:17:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_17_02():
    result = parse("B*35:17:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:17:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:17:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_17_03():
    result = parse("B*35:17:03")
    assert result.__class__ is Allele, f'Expected parse("B*35:17:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:17:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_17_04():
    result = parse("B*35:17:04")
    assert result.__class__ is Allele, f'Expected parse("B*35:17:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:17:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_18():
    result = parse("B*35:18")
    assert result.__class__ is Allele, f'Expected parse("B*35:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_180():
    result = parse("B*35:180")
    assert result.__class__ is Allele, f'Expected parse("B*35:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_181():
    result = parse("B*35:181")
    assert result.__class__ is Allele, f'Expected parse("B*35:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_182():
    result = parse("B*35:182")
    assert result.__class__ is Allele, f'Expected parse("B*35:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_183():
    result = parse("B*35:183")
    assert result.__class__ is Allele, f'Expected parse("B*35:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_184():
    result = parse("B*35:184")
    assert result.__class__ is Allele, f'Expected parse("B*35:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_185():
    result = parse("B*35:185")
    assert result.__class__ is Allele, f'Expected parse("B*35:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_186():
    result = parse("B*35:186")
    assert result.__class__ is Allele, f'Expected parse("B*35:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_187():
    result = parse("B*35:187")
    assert result.__class__ is Allele, f'Expected parse("B*35:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_188():
    result = parse("B*35:188")
    assert result.__class__ is Allele, f'Expected parse("B*35:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_189():
    result = parse("B*35:189")
    assert result.__class__ is Allele, f'Expected parse("B*35:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_19():
    result = parse("B*35:19")
    assert result.__class__ is Allele, f'Expected parse("B*35:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_190():
    result = parse("B*35:190")
    assert result.__class__ is Allele, f'Expected parse("B*35:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_191():
    result = parse("B*35:191")
    assert result.__class__ is Allele, f'Expected parse("B*35:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_192():
    result = parse("B*35:192")
    assert result.__class__ is Allele, f'Expected parse("B*35:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_193():
    result = parse("B*35:193")
    assert result.__class__ is Allele, f'Expected parse("B*35:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_194():
    result = parse("B*35:194")
    assert result.__class__ is Allele, f'Expected parse("B*35:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_195():
    result = parse("B*35:195")
    assert result.__class__ is Allele, f'Expected parse("B*35:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_196():
    result = parse("B*35:196")
    assert result.__class__ is Allele, f'Expected parse("B*35:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_197():
    result = parse("B*35:197")
    assert result.__class__ is Allele, f'Expected parse("B*35:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_198():
    result = parse("B*35:198")
    assert result.__class__ is Allele, f'Expected parse("B*35:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_199():
    result = parse("B*35:199")
    assert result.__class__ is Allele, f'Expected parse("B*35:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_200():
    result = parse("B*35:200")
    assert result.__class__ is Allele, f'Expected parse("B*35:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_201():
    result = parse("B*35:201")
    assert result.__class__ is Allele, f'Expected parse("B*35:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_202():
    result = parse("B*35:202")
    assert result.__class__ is Allele, f'Expected parse("B*35:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_203():
    result = parse("B*35:203")
    assert result.__class__ is Allele, f'Expected parse("B*35:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_204():
    result = parse("B*35:204")
    assert result.__class__ is Allele, f'Expected parse("B*35:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_205():
    result = parse("B*35:205")
    assert result.__class__ is Allele, f'Expected parse("B*35:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_206():
    result = parse("B*35:206")
    assert result.__class__ is Allele, f'Expected parse("B*35:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_207():
    result = parse("B*35:207")
    assert result.__class__ is Allele, f'Expected parse("B*35:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_208_01():
    result = parse("B*35:208:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:208:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:208:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_208_02():
    result = parse("B*35:208:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:208:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:208:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_209():
    result = parse("B*35:209")
    assert result.__class__ is Allele, f'Expected parse("B*35:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_20_01():
    result = parse("B*35:20:01")
    assert result.__class__ is Allele, f'Expected parse("B*35:20:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:20:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_20_02():
    result = parse("B*35:20:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:20:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:20:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_21():
    result = parse("B*35:21")
    assert result.__class__ is Allele, f'Expected parse("B*35:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_210():
    result = parse("B*35:210")
    assert result.__class__ is Allele, f'Expected parse("B*35:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_211():
    result = parse("B*35:211")
    assert result.__class__ is Allele, f'Expected parse("B*35:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_212():
    result = parse("B*35:212")
    assert result.__class__ is Allele, f'Expected parse("B*35:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_213():
    result = parse("B*35:213")
    assert result.__class__ is Allele, f'Expected parse("B*35:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_214():
    result = parse("B*35:214")
    assert result.__class__ is Allele, f'Expected parse("B*35:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_215():
    result = parse("B*35:215")
    assert result.__class__ is Allele, f'Expected parse("B*35:215") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_216N():
    result = parse("B*35:216N")
    assert result.__class__ is Allele, f'Expected parse("B*35:216N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:216N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_217():
    result = parse("B*35:217")
    assert result.__class__ is Allele, f'Expected parse("B*35:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_218():
    result = parse("B*35:218")
    assert result.__class__ is Allele, f'Expected parse("B*35:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_219():
    result = parse("B*35:219")
    assert result.__class__ is Allele, f'Expected parse("B*35:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_220():
    result = parse("B*35:220")
    assert result.__class__ is Allele, f'Expected parse("B*35:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_221():
    result = parse("B*35:221")
    assert result.__class__ is Allele, f'Expected parse("B*35:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_222():
    result = parse("B*35:222")
    assert result.__class__ is Allele, f'Expected parse("B*35:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_223():
    result = parse("B*35:223")
    assert result.__class__ is Allele, f'Expected parse("B*35:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_224():
    result = parse("B*35:224")
    assert result.__class__ is Allele, f'Expected parse("B*35:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_225():
    result = parse("B*35:225")
    assert result.__class__ is Allele, f'Expected parse("B*35:225") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_226():
    result = parse("B*35:226")
    assert result.__class__ is Allele, f'Expected parse("B*35:226") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_227():
    result = parse("B*35:227")
    assert result.__class__ is Allele, f'Expected parse("B*35:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_228():
    result = parse("B*35:228")
    assert result.__class__ is Allele, f'Expected parse("B*35:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_229():
    result = parse("B*35:229")
    assert result.__class__ is Allele, f'Expected parse("B*35:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_22_01_01():
    result = parse("B*35:22:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:22:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:22:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_22_01_02():
    result = parse("B*35:22:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:22:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:22:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_23():
    result = parse("B*35:23")
    assert result.__class__ is Allele, f'Expected parse("B*35:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_230():
    result = parse("B*35:230")
    assert result.__class__ is Allele, f'Expected parse("B*35:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_231():
    result = parse("B*35:231")
    assert result.__class__ is Allele, f'Expected parse("B*35:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_232():
    result = parse("B*35:232")
    assert result.__class__ is Allele, f'Expected parse("B*35:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_233():
    result = parse("B*35:233")
    assert result.__class__ is Allele, f'Expected parse("B*35:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_234():
    result = parse("B*35:234")
    assert result.__class__ is Allele, f'Expected parse("B*35:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_235():
    result = parse("B*35:235")
    assert result.__class__ is Allele, f'Expected parse("B*35:235") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_236():
    result = parse("B*35:236")
    assert result.__class__ is Allele, f'Expected parse("B*35:236") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_237():
    result = parse("B*35:237")
    assert result.__class__ is Allele, f'Expected parse("B*35:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_238():
    result = parse("B*35:238")
    assert result.__class__ is Allele, f'Expected parse("B*35:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_239():
    result = parse("B*35:239")
    assert result.__class__ is Allele, f'Expected parse("B*35:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_240():
    result = parse("B*35:240")
    assert result.__class__ is Allele, f'Expected parse("B*35:240") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_241():
    result = parse("B*35:241")
    assert result.__class__ is Allele, f'Expected parse("B*35:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_242():
    result = parse("B*35:242")
    assert result.__class__ is Allele, f'Expected parse("B*35:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_243():
    result = parse("B*35:243")
    assert result.__class__ is Allele, f'Expected parse("B*35:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_244():
    result = parse("B*35:244")
    assert result.__class__ is Allele, f'Expected parse("B*35:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_245():
    result = parse("B*35:245")
    assert result.__class__ is Allele, f'Expected parse("B*35:245") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_246():
    result = parse("B*35:246")
    assert result.__class__ is Allele, f'Expected parse("B*35:246") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_247():
    result = parse("B*35:247")
    assert result.__class__ is Allele, f'Expected parse("B*35:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_248():
    result = parse("B*35:248")
    assert result.__class__ is Allele, f'Expected parse("B*35:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_249():
    result = parse("B*35:249")
    assert result.__class__ is Allele, f'Expected parse("B*35:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_24_01():
    result = parse("B*35:24:01")
    assert result.__class__ is Allele, f'Expected parse("B*35:24:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:24:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_24_02():
    result = parse("B*35:24:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:24:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:24:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_25():
    result = parse("B*35:25")
    assert result.__class__ is Allele, f'Expected parse("B*35:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_250():
    result = parse("B*35:250")
    assert result.__class__ is Allele, f'Expected parse("B*35:250") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_251():
    result = parse("B*35:251")
    assert result.__class__ is Allele, f'Expected parse("B*35:251") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_252():
    result = parse("B*35:252")
    assert result.__class__ is Allele, f'Expected parse("B*35:252") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_253():
    result = parse("B*35:253")
    assert result.__class__ is Allele, f'Expected parse("B*35:253") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_254():
    result = parse("B*35:254")
    assert result.__class__ is Allele, f'Expected parse("B*35:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_255():
    result = parse("B*35:255")
    assert result.__class__ is Allele, f'Expected parse("B*35:255") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_256():
    result = parse("B*35:256")
    assert result.__class__ is Allele, f'Expected parse("B*35:256") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_257():
    result = parse("B*35:257")
    assert result.__class__ is Allele, f'Expected parse("B*35:257") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_258():
    result = parse("B*35:258")
    assert result.__class__ is Allele, f'Expected parse("B*35:258") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_259():
    result = parse("B*35:259")
    assert result.__class__ is Allele, f'Expected parse("B*35:259") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_26():
    result = parse("B*35:26")
    assert result.__class__ is Allele, f'Expected parse("B*35:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_260():
    result = parse("B*35:260")
    assert result.__class__ is Allele, f'Expected parse("B*35:260") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_261():
    result = parse("B*35:261")
    assert result.__class__ is Allele, f'Expected parse("B*35:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_262():
    result = parse("B*35:262")
    assert result.__class__ is Allele, f'Expected parse("B*35:262") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_263():
    result = parse("B*35:263")
    assert result.__class__ is Allele, f'Expected parse("B*35:263") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_264():
    result = parse("B*35:264")
    assert result.__class__ is Allele, f'Expected parse("B*35:264") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_265():
    result = parse("B*35:265")
    assert result.__class__ is Allele, f'Expected parse("B*35:265") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_266():
    result = parse("B*35:266")
    assert result.__class__ is Allele, f'Expected parse("B*35:266") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_267():
    result = parse("B*35:267")
    assert result.__class__ is Allele, f'Expected parse("B*35:267") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_268():
    result = parse("B*35:268")
    assert result.__class__ is Allele, f'Expected parse("B*35:268") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_269():
    result = parse("B*35:269")
    assert result.__class__ is Allele, f'Expected parse("B*35:269") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_27():
    result = parse("B*35:27")
    assert result.__class__ is Allele, f'Expected parse("B*35:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_270():
    result = parse("B*35:270")
    assert result.__class__ is Allele, f'Expected parse("B*35:270") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_271():
    result = parse("B*35:271")
    assert result.__class__ is Allele, f'Expected parse("B*35:271") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_272():
    result = parse("B*35:272")
    assert result.__class__ is Allele, f'Expected parse("B*35:272") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_273():
    result = parse("B*35:273")
    assert result.__class__ is Allele, f'Expected parse("B*35:273") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_274():
    result = parse("B*35:274")
    assert result.__class__ is Allele, f'Expected parse("B*35:274") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_275():
    result = parse("B*35:275")
    assert result.__class__ is Allele, f'Expected parse("B*35:275") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_276():
    result = parse("B*35:276")
    assert result.__class__ is Allele, f'Expected parse("B*35:276") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_277():
    result = parse("B*35:277")
    assert result.__class__ is Allele, f'Expected parse("B*35:277") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_278():
    result = parse("B*35:278")
    assert result.__class__ is Allele, f'Expected parse("B*35:278") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_279():
    result = parse("B*35:279")
    assert result.__class__ is Allele, f'Expected parse("B*35:279") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_280():
    result = parse("B*35:280")
    assert result.__class__ is Allele, f'Expected parse("B*35:280") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_281():
    result = parse("B*35:281")
    assert result.__class__ is Allele, f'Expected parse("B*35:281") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_282():
    result = parse("B*35:282")
    assert result.__class__ is Allele, f'Expected parse("B*35:282") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_283():
    result = parse("B*35:283")
    assert result.__class__ is Allele, f'Expected parse("B*35:283") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_284():
    result = parse("B*35:284")
    assert result.__class__ is Allele, f'Expected parse("B*35:284") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_285():
    result = parse("B*35:285")
    assert result.__class__ is Allele, f'Expected parse("B*35:285") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_286():
    result = parse("B*35:286")
    assert result.__class__ is Allele, f'Expected parse("B*35:286") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_287():
    result = parse("B*35:287")
    assert result.__class__ is Allele, f'Expected parse("B*35:287") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:287") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_288():
    result = parse("B*35:288")
    assert result.__class__ is Allele, f'Expected parse("B*35:288") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_289():
    result = parse("B*35:289")
    assert result.__class__ is Allele, f'Expected parse("B*35:289") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_28_01_01():
    result = parse("B*35:28:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:28:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:28:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_28_01_02():
    result = parse("B*35:28:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:28:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:28:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_28_01_03():
    result = parse("B*35:28:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:28:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:28:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_290():
    result = parse("B*35:290")
    assert result.__class__ is Allele, f'Expected parse("B*35:290") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_291():
    result = parse("B*35:291")
    assert result.__class__ is Allele, f'Expected parse("B*35:291") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_292():
    result = parse("B*35:292")
    assert result.__class__ is Allele, f'Expected parse("B*35:292") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_293():
    result = parse("B*35:293")
    assert result.__class__ is Allele, f'Expected parse("B*35:293") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_294():
    result = parse("B*35:294")
    assert result.__class__ is Allele, f'Expected parse("B*35:294") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_295():
    result = parse("B*35:295")
    assert result.__class__ is Allele, f'Expected parse("B*35:295") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_296():
    result = parse("B*35:296")
    assert result.__class__ is Allele, f'Expected parse("B*35:296") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_297():
    result = parse("B*35:297")
    assert result.__class__ is Allele, f'Expected parse("B*35:297") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_298():
    result = parse("B*35:298")
    assert result.__class__ is Allele, f'Expected parse("B*35:298") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_299():
    result = parse("B*35:299")
    assert result.__class__ is Allele, f'Expected parse("B*35:299") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_29_01():
    result = parse("B*35:29:01")
    assert result.__class__ is Allele, f'Expected parse("B*35:29:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:29:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_29_02():
    result = parse("B*35:29:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:29:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:29:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_300():
    result = parse("B*35:300")
    assert result.__class__ is Allele, f'Expected parse("B*35:300") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_301():
    result = parse("B*35:301")
    assert result.__class__ is Allele, f'Expected parse("B*35:301") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_302():
    result = parse("B*35:302")
    assert result.__class__ is Allele, f'Expected parse("B*35:302") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_303():
    result = parse("B*35:303")
    assert result.__class__ is Allele, f'Expected parse("B*35:303") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:303") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_304():
    result = parse("B*35:304")
    assert result.__class__ is Allele, f'Expected parse("B*35:304") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:304") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_305():
    result = parse("B*35:305")
    assert result.__class__ is Allele, f'Expected parse("B*35:305") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_306():
    result = parse("B*35:306")
    assert result.__class__ is Allele, f'Expected parse("B*35:306") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:306") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_307():
    result = parse("B*35:307")
    assert result.__class__ is Allele, f'Expected parse("B*35:307") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_308():
    result = parse("B*35:308")
    assert result.__class__ is Allele, f'Expected parse("B*35:308") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:308") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_309():
    result = parse("B*35:309")
    assert result.__class__ is Allele, f'Expected parse("B*35:309") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:309") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_30_01_01():
    result = parse("B*35:30:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:30:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:30:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_30_01_02():
    result = parse("B*35:30:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:30:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:30:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_31():
    result = parse("B*35:31")
    assert result.__class__ is Allele, f'Expected parse("B*35:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_310():
    result = parse("B*35:310")
    assert result.__class__ is Allele, f'Expected parse("B*35:310") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:310") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_311():
    result = parse("B*35:311")
    assert result.__class__ is Allele, f'Expected parse("B*35:311") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:311") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_312():
    result = parse("B*35:312")
    assert result.__class__ is Allele, f'Expected parse("B*35:312") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:312") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_313():
    result = parse("B*35:313")
    assert result.__class__ is Allele, f'Expected parse("B*35:313") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:313") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_314():
    result = parse("B*35:314")
    assert result.__class__ is Allele, f'Expected parse("B*35:314") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:314") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_315():
    result = parse("B*35:315")
    assert result.__class__ is Allele, f'Expected parse("B*35:315") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:315") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_316():
    result = parse("B*35:316")
    assert result.__class__ is Allele, f'Expected parse("B*35:316") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:316") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_317():
    result = parse("B*35:317")
    assert result.__class__ is Allele, f'Expected parse("B*35:317") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:317") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_318():
    result = parse("B*35:318")
    assert result.__class__ is Allele, f'Expected parse("B*35:318") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:318") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_319():
    result = parse("B*35:319")
    assert result.__class__ is Allele, f'Expected parse("B*35:319") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_320():
    result = parse("B*35:320")
    assert result.__class__ is Allele, f'Expected parse("B*35:320") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:320") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_321():
    result = parse("B*35:321")
    assert result.__class__ is Allele, f'Expected parse("B*35:321") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:321") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_322():
    result = parse("B*35:322")
    assert result.__class__ is Allele, f'Expected parse("B*35:322") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:322") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_323():
    result = parse("B*35:323")
    assert result.__class__ is Allele, f'Expected parse("B*35:323") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:323") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_324():
    result = parse("B*35:324")
    assert result.__class__ is Allele, f'Expected parse("B*35:324") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:324") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_325():
    result = parse("B*35:325")
    assert result.__class__ is Allele, f'Expected parse("B*35:325") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:325") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_326():
    result = parse("B*35:326")
    assert result.__class__ is Allele, f'Expected parse("B*35:326") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:326") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_327():
    result = parse("B*35:327")
    assert result.__class__ is Allele, f'Expected parse("B*35:327") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:327") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_328():
    result = parse("B*35:328")
    assert result.__class__ is Allele, f'Expected parse("B*35:328") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:328") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_329():
    result = parse("B*35:329")
    assert result.__class__ is Allele, f'Expected parse("B*35:329") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:329") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_32_01():
    result = parse("B*35:32:01")
    assert result.__class__ is Allele, f'Expected parse("B*35:32:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:32:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_32_02():
    result = parse("B*35:32:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:32:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:32:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_32_03():
    result = parse("B*35:32:03")
    assert result.__class__ is Allele, f'Expected parse("B*35:32:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:32:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_33():
    result = parse("B*35:33")
    assert result.__class__ is Allele, f'Expected parse("B*35:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_330():
    result = parse("B*35:330")
    assert result.__class__ is Allele, f'Expected parse("B*35:330") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:330") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_331():
    result = parse("B*35:331")
    assert result.__class__ is Allele, f'Expected parse("B*35:331") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:331") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_332():
    result = parse("B*35:332")
    assert result.__class__ is Allele, f'Expected parse("B*35:332") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:332") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_333Q():
    result = parse("B*35:333Q")
    assert result.__class__ is Allele, f'Expected parse("B*35:333Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:333Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_334():
    result = parse("B*35:334")
    assert result.__class__ is Allele, f'Expected parse("B*35:334") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:334") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_335():
    result = parse("B*35:335")
    assert result.__class__ is Allele, f'Expected parse("B*35:335") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:335") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_336():
    result = parse("B*35:336")
    assert result.__class__ is Allele, f'Expected parse("B*35:336") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:336") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_337_01():
    result = parse("B*35:337:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:337:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:337:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_337_02():
    result = parse("B*35:337:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:337:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:337:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_338():
    result = parse("B*35:338")
    assert result.__class__ is Allele, f'Expected parse("B*35:338") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:338") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_339():
    result = parse("B*35:339")
    assert result.__class__ is Allele, f'Expected parse("B*35:339") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:339") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_34():
    result = parse("B*35:34")
    assert result.__class__ is Allele, f'Expected parse("B*35:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_340():
    result = parse("B*35:340")
    assert result.__class__ is Allele, f'Expected parse("B*35:340") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:340") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_341():
    result = parse("B*35:341")
    assert result.__class__ is Allele, f'Expected parse("B*35:341") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:341") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_342():
    result = parse("B*35:342")
    assert result.__class__ is Allele, f'Expected parse("B*35:342") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:342") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_343():
    result = parse("B*35:343")
    assert result.__class__ is Allele, f'Expected parse("B*35:343") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:343") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_344():
    result = parse("B*35:344")
    assert result.__class__ is Allele, f'Expected parse("B*35:344") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:344") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_345():
    result = parse("B*35:345")
    assert result.__class__ is Allele, f'Expected parse("B*35:345") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:345") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_346():
    result = parse("B*35:346")
    assert result.__class__ is Allele, f'Expected parse("B*35:346") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:346") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_347():
    result = parse("B*35:347")
    assert result.__class__ is Allele, f'Expected parse("B*35:347") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:347") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_348():
    result = parse("B*35:348")
    assert result.__class__ is Allele, f'Expected parse("B*35:348") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:348") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_349():
    result = parse("B*35:349")
    assert result.__class__ is Allele, f'Expected parse("B*35:349") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:349") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_35():
    result = parse("B*35:35")
    assert result.__class__ is Allele, f'Expected parse("B*35:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_350():
    result = parse("B*35:350")
    assert result.__class__ is Allele, f'Expected parse("B*35:350") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:350") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_351():
    result = parse("B*35:351")
    assert result.__class__ is Allele, f'Expected parse("B*35:351") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:351") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_352():
    result = parse("B*35:352")
    assert result.__class__ is Allele, f'Expected parse("B*35:352") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:352") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_353():
    result = parse("B*35:353")
    assert result.__class__ is Allele, f'Expected parse("B*35:353") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:353") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_354():
    result = parse("B*35:354")
    assert result.__class__ is Allele, f'Expected parse("B*35:354") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:354") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_355():
    result = parse("B*35:355")
    assert result.__class__ is Allele, f'Expected parse("B*35:355") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:355") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_356():
    result = parse("B*35:356")
    assert result.__class__ is Allele, f'Expected parse("B*35:356") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:356") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_357():
    result = parse("B*35:357")
    assert result.__class__ is Allele, f'Expected parse("B*35:357") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:357") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_358():
    result = parse("B*35:358")
    assert result.__class__ is Allele, f'Expected parse("B*35:358") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:358") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_359():
    result = parse("B*35:359")
    assert result.__class__ is Allele, f'Expected parse("B*35:359") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:359") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_36():
    result = parse("B*35:36")
    assert result.__class__ is Allele, f'Expected parse("B*35:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_360():
    result = parse("B*35:360")
    assert result.__class__ is Allele, f'Expected parse("B*35:360") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:360") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_361():
    result = parse("B*35:361")
    assert result.__class__ is Allele, f'Expected parse("B*35:361") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:361") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_362():
    result = parse("B*35:362")
    assert result.__class__ is Allele, f'Expected parse("B*35:362") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:362") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_363():
    result = parse("B*35:363")
    assert result.__class__ is Allele, f'Expected parse("B*35:363") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:363") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_364():
    result = parse("B*35:364")
    assert result.__class__ is Allele, f'Expected parse("B*35:364") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:364") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_365():
    result = parse("B*35:365")
    assert result.__class__ is Allele, f'Expected parse("B*35:365") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:365") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_366():
    result = parse("B*35:366")
    assert result.__class__ is Allele, f'Expected parse("B*35:366") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:366") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_367():
    result = parse("B*35:367")
    assert result.__class__ is Allele, f'Expected parse("B*35:367") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:367") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_368():
    result = parse("B*35:368")
    assert result.__class__ is Allele, f'Expected parse("B*35:368") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:368") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_369():
    result = parse("B*35:369")
    assert result.__class__ is Allele, f'Expected parse("B*35:369") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:369") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_37():
    result = parse("B*35:37")
    assert result.__class__ is Allele, f'Expected parse("B*35:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_370():
    result = parse("B*35:370")
    assert result.__class__ is Allele, f'Expected parse("B*35:370") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:370") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_371():
    result = parse("B*35:371")
    assert result.__class__ is Allele, f'Expected parse("B*35:371") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:371") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_372():
    result = parse("B*35:372")
    assert result.__class__ is Allele, f'Expected parse("B*35:372") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:372") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_373():
    result = parse("B*35:373")
    assert result.__class__ is Allele, f'Expected parse("B*35:373") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:373") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_374():
    result = parse("B*35:374")
    assert result.__class__ is Allele, f'Expected parse("B*35:374") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:374") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_375():
    result = parse("B*35:375")
    assert result.__class__ is Allele, f'Expected parse("B*35:375") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:375") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_376():
    result = parse("B*35:376")
    assert result.__class__ is Allele, f'Expected parse("B*35:376") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:376") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_377():
    result = parse("B*35:377")
    assert result.__class__ is Allele, f'Expected parse("B*35:377") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:377") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_378():
    result = parse("B*35:378")
    assert result.__class__ is Allele, f'Expected parse("B*35:378") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:378") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_379():
    result = parse("B*35:379")
    assert result.__class__ is Allele, f'Expected parse("B*35:379") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:379") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_38():
    result = parse("B*35:38")
    assert result.__class__ is Allele, f'Expected parse("B*35:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_380_01_01():
    result = parse("B*35:380:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:380:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:380:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_380_01_02():
    result = parse("B*35:380:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:380:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:380:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_381N():
    result = parse("B*35:381N")
    assert result.__class__ is Allele, f'Expected parse("B*35:381N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:381N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_382():
    result = parse("B*35:382")
    assert result.__class__ is Allele, f'Expected parse("B*35:382") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:382") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_383():
    result = parse("B*35:383")
    assert result.__class__ is Allele, f'Expected parse("B*35:383") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:383") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_384():
    result = parse("B*35:384")
    assert result.__class__ is Allele, f'Expected parse("B*35:384") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:384") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_385():
    result = parse("B*35:385")
    assert result.__class__ is Allele, f'Expected parse("B*35:385") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:385") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_386():
    result = parse("B*35:386")
    assert result.__class__ is Allele, f'Expected parse("B*35:386") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:386") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_387():
    result = parse("B*35:387")
    assert result.__class__ is Allele, f'Expected parse("B*35:387") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:387") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_388():
    result = parse("B*35:388")
    assert result.__class__ is Allele, f'Expected parse("B*35:388") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:388") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_389():
    result = parse("B*35:389")
    assert result.__class__ is Allele, f'Expected parse("B*35:389") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:389") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_39():
    result = parse("B*35:39")
    assert result.__class__ is Allele, f'Expected parse("B*35:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_390N():
    result = parse("B*35:390N")
    assert result.__class__ is Allele, f'Expected parse("B*35:390N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:390N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_391():
    result = parse("B*35:391")
    assert result.__class__ is Allele, f'Expected parse("B*35:391") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:391") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_392():
    result = parse("B*35:392")
    assert result.__class__ is Allele, f'Expected parse("B*35:392") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:392") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_393():
    result = parse("B*35:393")
    assert result.__class__ is Allele, f'Expected parse("B*35:393") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:393") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_394():
    result = parse("B*35:394")
    assert result.__class__ is Allele, f'Expected parse("B*35:394") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:394") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_395():
    result = parse("B*35:395")
    assert result.__class__ is Allele, f'Expected parse("B*35:395") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:395") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_396():
    result = parse("B*35:396")
    assert result.__class__ is Allele, f'Expected parse("B*35:396") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:396") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_397():
    result = parse("B*35:397")
    assert result.__class__ is Allele, f'Expected parse("B*35:397") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:397") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_398():
    result = parse("B*35:398")
    assert result.__class__ is Allele, f'Expected parse("B*35:398") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:398") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_399():
    result = parse("B*35:399")
    assert result.__class__ is Allele, f'Expected parse("B*35:399") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:399") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_400():
    result = parse("B*35:400")
    assert result.__class__ is Allele, f'Expected parse("B*35:400") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:400") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_401():
    result = parse("B*35:401")
    assert result.__class__ is Allele, f'Expected parse("B*35:401") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:401") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_402():
    result = parse("B*35:402")
    assert result.__class__ is Allele, f'Expected parse("B*35:402") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:402") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_403():
    result = parse("B*35:403")
    assert result.__class__ is Allele, f'Expected parse("B*35:403") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:403") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_404():
    result = parse("B*35:404")
    assert result.__class__ is Allele, f'Expected parse("B*35:404") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:404") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_405():
    result = parse("B*35:405")
    assert result.__class__ is Allele, f'Expected parse("B*35:405") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:405") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_406():
    result = parse("B*35:406")
    assert result.__class__ is Allele, f'Expected parse("B*35:406") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:406") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_407():
    result = parse("B*35:407")
    assert result.__class__ is Allele, f'Expected parse("B*35:407") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:407") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_408():
    result = parse("B*35:408")
    assert result.__class__ is Allele, f'Expected parse("B*35:408") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:408") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_409():
    result = parse("B*35:409")
    assert result.__class__ is Allele, f'Expected parse("B*35:409") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:409") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_40N():
    result = parse("B*35:40N")
    assert result.__class__ is Allele, f'Expected parse("B*35:40N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:40N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_41():
    result = parse("B*35:41")
    assert result.__class__ is Allele, f'Expected parse("B*35:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_410():
    result = parse("B*35:410")
    assert result.__class__ is Allele, f'Expected parse("B*35:410") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:410") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_411():
    result = parse("B*35:411")
    assert result.__class__ is Allele, f'Expected parse("B*35:411") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:411") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_412():
    result = parse("B*35:412")
    assert result.__class__ is Allele, f'Expected parse("B*35:412") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:412") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_413():
    result = parse("B*35:413")
    assert result.__class__ is Allele, f'Expected parse("B*35:413") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:413") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_414():
    result = parse("B*35:414")
    assert result.__class__ is Allele, f'Expected parse("B*35:414") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:414") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_415():
    result = parse("B*35:415")
    assert result.__class__ is Allele, f'Expected parse("B*35:415") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:415") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_416():
    result = parse("B*35:416")
    assert result.__class__ is Allele, f'Expected parse("B*35:416") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:416") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_417():
    result = parse("B*35:417")
    assert result.__class__ is Allele, f'Expected parse("B*35:417") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:417") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_418():
    result = parse("B*35:418")
    assert result.__class__ is Allele, f'Expected parse("B*35:418") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:418") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_419():
    result = parse("B*35:419")
    assert result.__class__ is Allele, f'Expected parse("B*35:419") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:419") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_420():
    result = parse("B*35:420")
    assert result.__class__ is Allele, f'Expected parse("B*35:420") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:420") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_421():
    result = parse("B*35:421")
    assert result.__class__ is Allele, f'Expected parse("B*35:421") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:421") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_422():
    result = parse("B*35:422")
    assert result.__class__ is Allele, f'Expected parse("B*35:422") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:422") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_423():
    result = parse("B*35:423")
    assert result.__class__ is Allele, f'Expected parse("B*35:423") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:423") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_424():
    result = parse("B*35:424")
    assert result.__class__ is Allele, f'Expected parse("B*35:424") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:424") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_425():
    result = parse("B*35:425")
    assert result.__class__ is Allele, f'Expected parse("B*35:425") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:425") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_426():
    result = parse("B*35:426")
    assert result.__class__ is Allele, f'Expected parse("B*35:426") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:426") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_427N():
    result = parse("B*35:427N")
    assert result.__class__ is Allele, f'Expected parse("B*35:427N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:427N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_428Q():
    result = parse("B*35:428Q")
    assert result.__class__ is Allele, f'Expected parse("B*35:428Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:428Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_429():
    result = parse("B*35:429")
    assert result.__class__ is Allele, f'Expected parse("B*35:429") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:429") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_42_01():
    result = parse("B*35:42:01")
    assert result.__class__ is Allele, f'Expected parse("B*35:42:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:42:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_42_02():
    result = parse("B*35:42:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:42:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:42:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_430N():
    result = parse("B*35:430N")
    assert result.__class__ is Allele, f'Expected parse("B*35:430N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:430N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_431():
    result = parse("B*35:431")
    assert result.__class__ is Allele, f'Expected parse("B*35:431") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:431") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_432():
    result = parse("B*35:432")
    assert result.__class__ is Allele, f'Expected parse("B*35:432") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:432") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_433():
    result = parse("B*35:433")
    assert result.__class__ is Allele, f'Expected parse("B*35:433") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:433") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_434():
    result = parse("B*35:434")
    assert result.__class__ is Allele, f'Expected parse("B*35:434") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:434") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_435():
    result = parse("B*35:435")
    assert result.__class__ is Allele, f'Expected parse("B*35:435") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:435") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_436():
    result = parse("B*35:436")
    assert result.__class__ is Allele, f'Expected parse("B*35:436") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:436") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_437():
    result = parse("B*35:437")
    assert result.__class__ is Allele, f'Expected parse("B*35:437") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:437") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_438():
    result = parse("B*35:438")
    assert result.__class__ is Allele, f'Expected parse("B*35:438") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:438") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_439_01_01():
    result = parse("B*35:439:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:439:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:439:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_439_01_02():
    result = parse("B*35:439:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*35:439:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*35:439:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_43_01():
    result = parse("B*35:43:01")
    assert result.__class__ is Allele, f'Expected parse("B*35:43:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:43:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_43_03():
    result = parse("B*35:43:03")
    assert result.__class__ is Allele, f'Expected parse("B*35:43:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:43:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_43_04():
    result = parse("B*35:43:04")
    assert result.__class__ is Allele, f'Expected parse("B*35:43:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:43:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_44():
    result = parse("B*35:44")
    assert result.__class__ is Allele, f'Expected parse("B*35:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_440():
    result = parse("B*35:440")
    assert result.__class__ is Allele, f'Expected parse("B*35:440") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:440") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_441():
    result = parse("B*35:441")
    assert result.__class__ is Allele, f'Expected parse("B*35:441") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:441") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_442():
    result = parse("B*35:442")
    assert result.__class__ is Allele, f'Expected parse("B*35:442") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:442") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_443():
    result = parse("B*35:443")
    assert result.__class__ is Allele, f'Expected parse("B*35:443") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:443") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_444():
    result = parse("B*35:444")
    assert result.__class__ is Allele, f'Expected parse("B*35:444") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:444") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_445():
    result = parse("B*35:445")
    assert result.__class__ is Allele, f'Expected parse("B*35:445") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:445") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_446():
    result = parse("B*35:446")
    assert result.__class__ is Allele, f'Expected parse("B*35:446") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:446") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_447():
    result = parse("B*35:447")
    assert result.__class__ is Allele, f'Expected parse("B*35:447") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:447") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_448N():
    result = parse("B*35:448N")
    assert result.__class__ is Allele, f'Expected parse("B*35:448N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:448N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_449():
    result = parse("B*35:449")
    assert result.__class__ is Allele, f'Expected parse("B*35:449") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:449") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_45():
    result = parse("B*35:45")
    assert result.__class__ is Allele, f'Expected parse("B*35:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_450():
    result = parse("B*35:450")
    assert result.__class__ is Allele, f'Expected parse("B*35:450") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:450") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_451():
    result = parse("B*35:451")
    assert result.__class__ is Allele, f'Expected parse("B*35:451") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:451") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_452():
    result = parse("B*35:452")
    assert result.__class__ is Allele, f'Expected parse("B*35:452") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:452") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_453N():
    result = parse("B*35:453N")
    assert result.__class__ is Allele, f'Expected parse("B*35:453N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:453N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_454():
    result = parse("B*35:454")
    assert result.__class__ is Allele, f'Expected parse("B*35:454") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:454") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_455():
    result = parse("B*35:455")
    assert result.__class__ is Allele, f'Expected parse("B*35:455") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:455") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_456N():
    result = parse("B*35:456N")
    assert result.__class__ is Allele, f'Expected parse("B*35:456N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:456N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_457():
    result = parse("B*35:457")
    assert result.__class__ is Allele, f'Expected parse("B*35:457") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:457") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_458():
    result = parse("B*35:458")
    assert result.__class__ is Allele, f'Expected parse("B*35:458") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:458") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_459N():
    result = parse("B*35:459N")
    assert result.__class__ is Allele, f'Expected parse("B*35:459N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:459N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_46():
    result = parse("B*35:46")
    assert result.__class__ is Allele, f'Expected parse("B*35:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_460():
    result = parse("B*35:460")
    assert result.__class__ is Allele, f'Expected parse("B*35:460") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:460") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_461N():
    result = parse("B*35:461N")
    assert result.__class__ is Allele, f'Expected parse("B*35:461N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:461N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_462():
    result = parse("B*35:462")
    assert result.__class__ is Allele, f'Expected parse("B*35:462") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:462") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_463():
    result = parse("B*35:463")
    assert result.__class__ is Allele, f'Expected parse("B*35:463") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:463") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_464():
    result = parse("B*35:464")
    assert result.__class__ is Allele, f'Expected parse("B*35:464") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:464") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_465():
    result = parse("B*35:465")
    assert result.__class__ is Allele, f'Expected parse("B*35:465") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:465") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_466():
    result = parse("B*35:466")
    assert result.__class__ is Allele, f'Expected parse("B*35:466") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:466") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_467():
    result = parse("B*35:467")
    assert result.__class__ is Allele, f'Expected parse("B*35:467") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:467") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_468():
    result = parse("B*35:468")
    assert result.__class__ is Allele, f'Expected parse("B*35:468") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:468") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_469():
    result = parse("B*35:469")
    assert result.__class__ is Allele, f'Expected parse("B*35:469") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:469") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_47():
    result = parse("B*35:47")
    assert result.__class__ is Allele, f'Expected parse("B*35:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_470():
    result = parse("B*35:470")
    assert result.__class__ is Allele, f'Expected parse("B*35:470") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:470") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_471():
    result = parse("B*35:471")
    assert result.__class__ is Allele, f'Expected parse("B*35:471") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:471") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_472():
    result = parse("B*35:472")
    assert result.__class__ is Allele, f'Expected parse("B*35:472") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:472") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_473():
    result = parse("B*35:473")
    assert result.__class__ is Allele, f'Expected parse("B*35:473") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:473") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_474():
    result = parse("B*35:474")
    assert result.__class__ is Allele, f'Expected parse("B*35:474") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:474") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_475():
    result = parse("B*35:475")
    assert result.__class__ is Allele, f'Expected parse("B*35:475") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:475") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_476():
    result = parse("B*35:476")
    assert result.__class__ is Allele, f'Expected parse("B*35:476") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:476") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_477():
    result = parse("B*35:477")
    assert result.__class__ is Allele, f'Expected parse("B*35:477") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:477") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_478():
    result = parse("B*35:478")
    assert result.__class__ is Allele, f'Expected parse("B*35:478") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:478") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_479():
    result = parse("B*35:479")
    assert result.__class__ is Allele, f'Expected parse("B*35:479") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:479") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_48():
    result = parse("B*35:48")
    assert result.__class__ is Allele, f'Expected parse("B*35:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_480():
    result = parse("B*35:480")
    assert result.__class__ is Allele, f'Expected parse("B*35:480") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:480") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_481():
    result = parse("B*35:481")
    assert result.__class__ is Allele, f'Expected parse("B*35:481") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:481") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_482():
    result = parse("B*35:482")
    assert result.__class__ is Allele, f'Expected parse("B*35:482") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:482") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_483():
    result = parse("B*35:483")
    assert result.__class__ is Allele, f'Expected parse("B*35:483") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:483") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_484():
    result = parse("B*35:484")
    assert result.__class__ is Allele, f'Expected parse("B*35:484") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:484") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_485():
    result = parse("B*35:485")
    assert result.__class__ is Allele, f'Expected parse("B*35:485") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:485") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_486():
    result = parse("B*35:486")
    assert result.__class__ is Allele, f'Expected parse("B*35:486") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:486") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_487():
    result = parse("B*35:487")
    assert result.__class__ is Allele, f'Expected parse("B*35:487") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:487") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_488():
    result = parse("B*35:488")
    assert result.__class__ is Allele, f'Expected parse("B*35:488") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:488") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_489():
    result = parse("B*35:489")
    assert result.__class__ is Allele, f'Expected parse("B*35:489") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:489") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_49_01():
    result = parse("B*35:49:01")
    assert result.__class__ is Allele, f'Expected parse("B*35:49:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:49:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_49_02():
    result = parse("B*35:49:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:49:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:49:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_50():
    result = parse("B*35:50")
    assert result.__class__ is Allele, f'Expected parse("B*35:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_51():
    result = parse("B*35:51")
    assert result.__class__ is Allele, f'Expected parse("B*35:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_52():
    result = parse("B*35:52")
    assert result.__class__ is Allele, f'Expected parse("B*35:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_53N():
    result = parse("B*35:53N")
    assert result.__class__ is Allele, f'Expected parse("B*35:53N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:53N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_54():
    result = parse("B*35:54")
    assert result.__class__ is Allele, f'Expected parse("B*35:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_55():
    result = parse("B*35:55")
    assert result.__class__ is Allele, f'Expected parse("B*35:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_56():
    result = parse("B*35:56")
    assert result.__class__ is Allele, f'Expected parse("B*35:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_57():
    result = parse("B*35:57")
    assert result.__class__ is Allele, f'Expected parse("B*35:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_58():
    result = parse("B*35:58")
    assert result.__class__ is Allele, f'Expected parse("B*35:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_59_01():
    result = parse("B*35:59:01")
    assert result.__class__ is Allele, f'Expected parse("B*35:59:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:59:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_59_02():
    result = parse("B*35:59:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:59:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:59:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_60():
    result = parse("B*35:60")
    assert result.__class__ is Allele, f'Expected parse("B*35:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_61_01():
    result = parse("B*35:61:01")
    assert result.__class__ is Allele, f'Expected parse("B*35:61:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:61:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_61_02():
    result = parse("B*35:61:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:61:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:61:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_62():
    result = parse("B*35:62")
    assert result.__class__ is Allele, f'Expected parse("B*35:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_63():
    result = parse("B*35:63")
    assert result.__class__ is Allele, f'Expected parse("B*35:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_64_01():
    result = parse("B*35:64:01")
    assert result.__class__ is Allele, f'Expected parse("B*35:64:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:64:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_64_02():
    result = parse("B*35:64:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:64:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:64:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_65Q():
    result = parse("B*35:65Q")
    assert result.__class__ is Allele, f'Expected parse("B*35:65Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:65Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_66():
    result = parse("B*35:66")
    assert result.__class__ is Allele, f'Expected parse("B*35:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_67():
    result = parse("B*35:67")
    assert result.__class__ is Allele, f'Expected parse("B*35:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_68_01():
    result = parse("B*35:68:01")
    assert result.__class__ is Allele, f'Expected parse("B*35:68:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:68:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_68_02():
    result = parse("B*35:68:02")
    assert result.__class__ is Allele, f'Expected parse("B*35:68:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*35:68:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_69():
    result = parse("B*35:69")
    assert result.__class__ is Allele, f'Expected parse("B*35:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_70():
    result = parse("B*35:70")
    assert result.__class__ is Allele, f'Expected parse("B*35:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_71():
    result = parse("B*35:71")
    assert result.__class__ is Allele, f'Expected parse("B*35:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_72():
    result = parse("B*35:72")
    assert result.__class__ is Allele, f'Expected parse("B*35:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_74():
    result = parse("B*35:74")
    assert result.__class__ is Allele, f'Expected parse("B*35:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_75():
    result = parse("B*35:75")
    assert result.__class__ is Allele, f'Expected parse("B*35:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_76():
    result = parse("B*35:76")
    assert result.__class__ is Allele, f'Expected parse("B*35:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_77():
    result = parse("B*35:77")
    assert result.__class__ is Allele, f'Expected parse("B*35:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_78():
    result = parse("B*35:78")
    assert result.__class__ is Allele, f'Expected parse("B*35:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_79():
    result = parse("B*35:79")
    assert result.__class__ is Allele, f'Expected parse("B*35:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_80():
    result = parse("B*35:80")
    assert result.__class__ is Allele, f'Expected parse("B*35:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_81():
    result = parse("B*35:81")
    assert result.__class__ is Allele, f'Expected parse("B*35:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_82():
    result = parse("B*35:82")
    assert result.__class__ is Allele, f'Expected parse("B*35:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_83():
    result = parse("B*35:83")
    assert result.__class__ is Allele, f'Expected parse("B*35:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_84():
    result = parse("B*35:84")
    assert result.__class__ is Allele, f'Expected parse("B*35:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_85():
    result = parse("B*35:85")
    assert result.__class__ is Allele, f'Expected parse("B*35:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_86():
    result = parse("B*35:86")
    assert result.__class__ is Allele, f'Expected parse("B*35:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_87():
    result = parse("B*35:87")
    assert result.__class__ is Allele, f'Expected parse("B*35:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_88():
    result = parse("B*35:88")
    assert result.__class__ is Allele, f'Expected parse("B*35:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_89():
    result = parse("B*35:89")
    assert result.__class__ is Allele, f'Expected parse("B*35:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_90():
    result = parse("B*35:90")
    assert result.__class__ is Allele, f'Expected parse("B*35:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_91():
    result = parse("B*35:91")
    assert result.__class__ is Allele, f'Expected parse("B*35:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_92():
    result = parse("B*35:92")
    assert result.__class__ is Allele, f'Expected parse("B*35:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_93():
    result = parse("B*35:93")
    assert result.__class__ is Allele, f'Expected parse("B*35:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_94():
    result = parse("B*35:94")
    assert result.__class__ is Allele, f'Expected parse("B*35:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_95():
    result = parse("B*35:95")
    assert result.__class__ is Allele, f'Expected parse("B*35:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_96():
    result = parse("B*35:96")
    assert result.__class__ is Allele, f'Expected parse("B*35:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_97():
    result = parse("B*35:97")
    assert result.__class__ is Allele, f'Expected parse("B*35:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_98():
    result = parse("B*35:98")
    assert result.__class__ is Allele, f'Expected parse("B*35:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_35_99():
    result = parse("B*35:99")
    assert result.__class__ is Allele, f'Expected parse("B*35:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*35:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_01_01():
    result = parse("B*37:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*37:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*37:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_01_02():
    result = parse("B*37:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*37:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*37:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_01_03():
    result = parse("B*37:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*37:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*37:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_01_04():
    result = parse("B*37:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*37:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*37:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_01_05():
    result = parse("B*37:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*37:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*37:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_01_06():
    result = parse("B*37:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*37:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*37:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_01_07():
    result = parse("B*37:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*37:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*37:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_01_08():
    result = parse("B*37:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*37:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*37:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_01_09():
    result = parse("B*37:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*37:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*37:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_01_10():
    result = parse("B*37:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*37:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*37:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_01_11():
    result = parse("B*37:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*37:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*37:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_02():
    result = parse("B*37:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_03():
    result = parse("B*37:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_04():
    result = parse("B*37:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_05():
    result = parse("B*37:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_06():
    result = parse("B*37:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_07():
    result = parse("B*37:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_08():
    result = parse("B*37:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_09():
    result = parse("B*37:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_10():
    result = parse("B*37:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_11():
    result = parse("B*37:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_12():
    result = parse("B*37:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_13():
    result = parse("B*37:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_14():
    result = parse("B*37:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_15():
    result = parse("B*37:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_16():
    result = parse("B*37:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_17():
    result = parse("B*37:01:17")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_18():
    result = parse("B*37:01:18")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_19():
    result = parse("B*37:01:19")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_20():
    result = parse("B*37:01:20")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_21():
    result = parse("B*37:01:21")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_01_22():
    result = parse("B*37:01:22")
    assert result.__class__ is Allele, f'Expected parse("B*37:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_02():
    result = parse("B*37:02")
    assert result.__class__ is Allele, f'Expected parse("B*37:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_03N():
    result = parse("B*37:03N")
    assert result.__class__ is Allele, f'Expected parse("B*37:03N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:03N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_04_01():
    result = parse("B*37:04:01")
    assert result.__class__ is Allele, f'Expected parse("B*37:04:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_04_02():
    result = parse("B*37:04:02")
    assert result.__class__ is Allele, f'Expected parse("B*37:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_05():
    result = parse("B*37:05")
    assert result.__class__ is Allele, f'Expected parse("B*37:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_06_01():
    result = parse("B*37:06:01")
    assert result.__class__ is Allele, f'Expected parse("B*37:06:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_06_02():
    result = parse("B*37:06:02")
    assert result.__class__ is Allele, f'Expected parse("B*37:06:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_07():
    result = parse("B*37:07")
    assert result.__class__ is Allele, f'Expected parse("B*37:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_08():
    result = parse("B*37:08")
    assert result.__class__ is Allele, f'Expected parse("B*37:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_09():
    result = parse("B*37:09")
    assert result.__class__ is Allele, f'Expected parse("B*37:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_10():
    result = parse("B*37:10")
    assert result.__class__ is Allele, f'Expected parse("B*37:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_11():
    result = parse("B*37:11")
    assert result.__class__ is Allele, f'Expected parse("B*37:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_12():
    result = parse("B*37:12")
    assert result.__class__ is Allele, f'Expected parse("B*37:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_13():
    result = parse("B*37:13")
    assert result.__class__ is Allele, f'Expected parse("B*37:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_14():
    result = parse("B*37:14")
    assert result.__class__ is Allele, f'Expected parse("B*37:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_15():
    result = parse("B*37:15")
    assert result.__class__ is Allele, f'Expected parse("B*37:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_16Q():
    result = parse("B*37:16Q")
    assert result.__class__ is Allele, f'Expected parse("B*37:16Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:16Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_17():
    result = parse("B*37:17")
    assert result.__class__ is Allele, f'Expected parse("B*37:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_18():
    result = parse("B*37:18")
    assert result.__class__ is Allele, f'Expected parse("B*37:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_19_01():
    result = parse("B*37:19:01")
    assert result.__class__ is Allele, f'Expected parse("B*37:19:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:19:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_19_02():
    result = parse("B*37:19:02")
    assert result.__class__ is Allele, f'Expected parse("B*37:19:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:19:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_20():
    result = parse("B*37:20")
    assert result.__class__ is Allele, f'Expected parse("B*37:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_21():
    result = parse("B*37:21")
    assert result.__class__ is Allele, f'Expected parse("B*37:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_22_01():
    result = parse("B*37:22:01")
    assert result.__class__ is Allele, f'Expected parse("B*37:22:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:22:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_22_02():
    result = parse("B*37:22:02")
    assert result.__class__ is Allele, f'Expected parse("B*37:22:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*37:22:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_23():
    result = parse("B*37:23")
    assert result.__class__ is Allele, f'Expected parse("B*37:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_24():
    result = parse("B*37:24")
    assert result.__class__ is Allele, f'Expected parse("B*37:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_25():
    result = parse("B*37:25")
    assert result.__class__ is Allele, f'Expected parse("B*37:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_26():
    result = parse("B*37:26")
    assert result.__class__ is Allele, f'Expected parse("B*37:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_27():
    result = parse("B*37:27")
    assert result.__class__ is Allele, f'Expected parse("B*37:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_28():
    result = parse("B*37:28")
    assert result.__class__ is Allele, f'Expected parse("B*37:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_29():
    result = parse("B*37:29")
    assert result.__class__ is Allele, f'Expected parse("B*37:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_30N():
    result = parse("B*37:30N")
    assert result.__class__ is Allele, f'Expected parse("B*37:30N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:30N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_31():
    result = parse("B*37:31")
    assert result.__class__ is Allele, f'Expected parse("B*37:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_32():
    result = parse("B*37:32")
    assert result.__class__ is Allele, f'Expected parse("B*37:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_33N():
    result = parse("B*37:33N")
    assert result.__class__ is Allele, f'Expected parse("B*37:33N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:33N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_34():
    result = parse("B*37:34")
    assert result.__class__ is Allele, f'Expected parse("B*37:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_35():
    result = parse("B*37:35")
    assert result.__class__ is Allele, f'Expected parse("B*37:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_36():
    result = parse("B*37:36")
    assert result.__class__ is Allele, f'Expected parse("B*37:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_37():
    result = parse("B*37:37")
    assert result.__class__ is Allele, f'Expected parse("B*37:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_38():
    result = parse("B*37:38")
    assert result.__class__ is Allele, f'Expected parse("B*37:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_39():
    result = parse("B*37:39")
    assert result.__class__ is Allele, f'Expected parse("B*37:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_40():
    result = parse("B*37:40")
    assert result.__class__ is Allele, f'Expected parse("B*37:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_41():
    result = parse("B*37:41")
    assert result.__class__ is Allele, f'Expected parse("B*37:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_42N():
    result = parse("B*37:42N")
    assert result.__class__ is Allele, f'Expected parse("B*37:42N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:42N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_43():
    result = parse("B*37:43")
    assert result.__class__ is Allele, f'Expected parse("B*37:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_44():
    result = parse("B*37:44")
    assert result.__class__ is Allele, f'Expected parse("B*37:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_45():
    result = parse("B*37:45")
    assert result.__class__ is Allele, f'Expected parse("B*37:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_46():
    result = parse("B*37:46")
    assert result.__class__ is Allele, f'Expected parse("B*37:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_47():
    result = parse("B*37:47")
    assert result.__class__ is Allele, f'Expected parse("B*37:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_48():
    result = parse("B*37:48")
    assert result.__class__ is Allele, f'Expected parse("B*37:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_49():
    result = parse("B*37:49")
    assert result.__class__ is Allele, f'Expected parse("B*37:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_50():
    result = parse("B*37:50")
    assert result.__class__ is Allele, f'Expected parse("B*37:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_51():
    result = parse("B*37:51")
    assert result.__class__ is Allele, f'Expected parse("B*37:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_52():
    result = parse("B*37:52")
    assert result.__class__ is Allele, f'Expected parse("B*37:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_53():
    result = parse("B*37:53")
    assert result.__class__ is Allele, f'Expected parse("B*37:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_54():
    result = parse("B*37:54")
    assert result.__class__ is Allele, f'Expected parse("B*37:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_55():
    result = parse("B*37:55")
    assert result.__class__ is Allele, f'Expected parse("B*37:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_56():
    result = parse("B*37:56")
    assert result.__class__ is Allele, f'Expected parse("B*37:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_57():
    result = parse("B*37:57")
    assert result.__class__ is Allele, f'Expected parse("B*37:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_58():
    result = parse("B*37:58")
    assert result.__class__ is Allele, f'Expected parse("B*37:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_59():
    result = parse("B*37:59")
    assert result.__class__ is Allele, f'Expected parse("B*37:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_60():
    result = parse("B*37:60")
    assert result.__class__ is Allele, f'Expected parse("B*37:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_61():
    result = parse("B*37:61")
    assert result.__class__ is Allele, f'Expected parse("B*37:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_62():
    result = parse("B*37:62")
    assert result.__class__ is Allele, f'Expected parse("B*37:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_63():
    result = parse("B*37:63")
    assert result.__class__ is Allele, f'Expected parse("B*37:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_64():
    result = parse("B*37:64")
    assert result.__class__ is Allele, f'Expected parse("B*37:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_65():
    result = parse("B*37:65")
    assert result.__class__ is Allele, f'Expected parse("B*37:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_66():
    result = parse("B*37:66")
    assert result.__class__ is Allele, f'Expected parse("B*37:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_67():
    result = parse("B*37:67")
    assert result.__class__ is Allele, f'Expected parse("B*37:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_68():
    result = parse("B*37:68")
    assert result.__class__ is Allele, f'Expected parse("B*37:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_69():
    result = parse("B*37:69")
    assert result.__class__ is Allele, f'Expected parse("B*37:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_70():
    result = parse("B*37:70")
    assert result.__class__ is Allele, f'Expected parse("B*37:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_71():
    result = parse("B*37:71")
    assert result.__class__ is Allele, f'Expected parse("B*37:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_72():
    result = parse("B*37:72")
    assert result.__class__ is Allele, f'Expected parse("B*37:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_73():
    result = parse("B*37:73")
    assert result.__class__ is Allele, f'Expected parse("B*37:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_74():
    result = parse("B*37:74")
    assert result.__class__ is Allele, f'Expected parse("B*37:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_75():
    result = parse("B*37:75")
    assert result.__class__ is Allele, f'Expected parse("B*37:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_76():
    result = parse("B*37:76")
    assert result.__class__ is Allele, f'Expected parse("B*37:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_77():
    result = parse("B*37:77")
    assert result.__class__ is Allele, f'Expected parse("B*37:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_78():
    result = parse("B*37:78")
    assert result.__class__ is Allele, f'Expected parse("B*37:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_79N():
    result = parse("B*37:79N")
    assert result.__class__ is Allele, f'Expected parse("B*37:79N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:79N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_80():
    result = parse("B*37:80")
    assert result.__class__ is Allele, f'Expected parse("B*37:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_81():
    result = parse("B*37:81")
    assert result.__class__ is Allele, f'Expected parse("B*37:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_82N():
    result = parse("B*37:82N")
    assert result.__class__ is Allele, f'Expected parse("B*37:82N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:82N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_83():
    result = parse("B*37:83")
    assert result.__class__ is Allele, f'Expected parse("B*37:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_84():
    result = parse("B*37:84")
    assert result.__class__ is Allele, f'Expected parse("B*37:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_85():
    result = parse("B*37:85")
    assert result.__class__ is Allele, f'Expected parse("B*37:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_86N():
    result = parse("B*37:86N")
    assert result.__class__ is Allele, f'Expected parse("B*37:86N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:86N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_87():
    result = parse("B*37:87")
    assert result.__class__ is Allele, f'Expected parse("B*37:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_88():
    result = parse("B*37:88")
    assert result.__class__ is Allele, f'Expected parse("B*37:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_89():
    result = parse("B*37:89")
    assert result.__class__ is Allele, f'Expected parse("B*37:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_90():
    result = parse("B*37:90")
    assert result.__class__ is Allele, f'Expected parse("B*37:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_91():
    result = parse("B*37:91")
    assert result.__class__ is Allele, f'Expected parse("B*37:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_92N():
    result = parse("B*37:92N")
    assert result.__class__ is Allele, f'Expected parse("B*37:92N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:92N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_93():
    result = parse("B*37:93")
    assert result.__class__ is Allele, f'Expected parse("B*37:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_37_94():
    result = parse("B*37:94")
    assert result.__class__ is Allele, f'Expected parse("B*37:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*37:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_01_01():
    result = parse("B*38:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*38:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*38:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_01_02():
    result = parse("B*38:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*38:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*38:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_01_03Q():
    result = parse("B*38:01:01:03Q")
    assert result.__class__ is Allele, (
        f'Expected parse("B*38:01:01:03Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*38:01:01:03Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_01_04():
    result = parse("B*38:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*38:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*38:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_01_05():
    result = parse("B*38:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*38:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*38:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_01_06():
    result = parse("B*38:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*38:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*38:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_01_07():
    result = parse("B*38:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*38:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*38:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_01_08():
    result = parse("B*38:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*38:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*38:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_01_09():
    result = parse("B*38:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*38:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*38:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_01_10():
    result = parse("B*38:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*38:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*38:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_01_11():
    result = parse("B*38:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*38:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*38:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_02():
    result = parse("B*38:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*38:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_03():
    result = parse("B*38:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*38:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_04():
    result = parse("B*38:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*38:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_05():
    result = parse("B*38:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*38:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_06():
    result = parse("B*38:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*38:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_07():
    result = parse("B*38:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*38:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_08():
    result = parse("B*38:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*38:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_09():
    result = parse("B*38:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*38:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_10():
    result = parse("B*38:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*38:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_11():
    result = parse("B*38:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*38:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_12():
    result = parse("B*38:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*38:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_13():
    result = parse("B*38:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*38:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_14():
    result = parse("B*38:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*38:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_15():
    result = parse("B*38:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*38:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_16():
    result = parse("B*38:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*38:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_01_17():
    result = parse("B*38:01:17")
    assert result.__class__ is Allele, f'Expected parse("B*38:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_02_01_01():
    result = parse("B*38:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*38:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*38:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_02_01_02():
    result = parse("B*38:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*38:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*38:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_02_02_01():
    result = parse("B*38:02:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*38:02:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*38:02:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_02_02_02():
    result = parse("B*38:02:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*38:02:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*38:02:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_02_03():
    result = parse("B*38:02:03")
    assert result.__class__ is Allele, f'Expected parse("B*38:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_02_04():
    result = parse("B*38:02:04")
    assert result.__class__ is Allele, f'Expected parse("B*38:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_02_05():
    result = parse("B*38:02:05")
    assert result.__class__ is Allele, f'Expected parse("B*38:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_02_06():
    result = parse("B*38:02:06")
    assert result.__class__ is Allele, f'Expected parse("B*38:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_02_07():
    result = parse("B*38:02:07")
    assert result.__class__ is Allele, f'Expected parse("B*38:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_02_08():
    result = parse("B*38:02:08")
    assert result.__class__ is Allele, f'Expected parse("B*38:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_02_09():
    result = parse("B*38:02:09")
    assert result.__class__ is Allele, f'Expected parse("B*38:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_02_10():
    result = parse("B*38:02:10")
    assert result.__class__ is Allele, f'Expected parse("B*38:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_03():
    result = parse("B*38:03")
    assert result.__class__ is Allele, f'Expected parse("B*38:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_04():
    result = parse("B*38:04")
    assert result.__class__ is Allele, f'Expected parse("B*38:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_05():
    result = parse("B*38:05")
    assert result.__class__ is Allele, f'Expected parse("B*38:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_06():
    result = parse("B*38:06")
    assert result.__class__ is Allele, f'Expected parse("B*38:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_07():
    result = parse("B*38:07")
    assert result.__class__ is Allele, f'Expected parse("B*38:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_08():
    result = parse("B*38:08")
    assert result.__class__ is Allele, f'Expected parse("B*38:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_09():
    result = parse("B*38:09")
    assert result.__class__ is Allele, f'Expected parse("B*38:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_10():
    result = parse("B*38:10")
    assert result.__class__ is Allele, f'Expected parse("B*38:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_11():
    result = parse("B*38:11")
    assert result.__class__ is Allele, f'Expected parse("B*38:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_12():
    result = parse("B*38:12")
    assert result.__class__ is Allele, f'Expected parse("B*38:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_13():
    result = parse("B*38:13")
    assert result.__class__ is Allele, f'Expected parse("B*38:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_14():
    result = parse("B*38:14")
    assert result.__class__ is Allele, f'Expected parse("B*38:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_15():
    result = parse("B*38:15")
    assert result.__class__ is Allele, f'Expected parse("B*38:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_156():
    result = parse("B*38:156")
    assert result.__class__ is Allele, f'Expected parse("B*38:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_157():
    result = parse("B*38:157")
    assert result.__class__ is Allele, f'Expected parse("B*38:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_158():
    result = parse("B*38:158")
    assert result.__class__ is Allele, f'Expected parse("B*38:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_159():
    result = parse("B*38:159")
    assert result.__class__ is Allele, f'Expected parse("B*38:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_16():
    result = parse("B*38:16")
    assert result.__class__ is Allele, f'Expected parse("B*38:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_160():
    result = parse("B*38:160")
    assert result.__class__ is Allele, f'Expected parse("B*38:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_161():
    result = parse("B*38:161")
    assert result.__class__ is Allele, f'Expected parse("B*38:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_162():
    result = parse("B*38:162")
    assert result.__class__ is Allele, f'Expected parse("B*38:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_163():
    result = parse("B*38:163")
    assert result.__class__ is Allele, f'Expected parse("B*38:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_164():
    result = parse("B*38:164")
    assert result.__class__ is Allele, f'Expected parse("B*38:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_165N():
    result = parse("B*38:165N")
    assert result.__class__ is Allele, f'Expected parse("B*38:165N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:165N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_166():
    result = parse("B*38:166")
    assert result.__class__ is Allele, f'Expected parse("B*38:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_167():
    result = parse("B*38:167")
    assert result.__class__ is Allele, f'Expected parse("B*38:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_168():
    result = parse("B*38:168")
    assert result.__class__ is Allele, f'Expected parse("B*38:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_17():
    result = parse("B*38:17")
    assert result.__class__ is Allele, f'Expected parse("B*38:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_18():
    result = parse("B*38:18")
    assert result.__class__ is Allele, f'Expected parse("B*38:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_19():
    result = parse("B*38:19")
    assert result.__class__ is Allele, f'Expected parse("B*38:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_20_01():
    result = parse("B*38:20:01")
    assert result.__class__ is Allele, f'Expected parse("B*38:20:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:20:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_20_02():
    result = parse("B*38:20:02")
    assert result.__class__ is Allele, f'Expected parse("B*38:20:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*38:20:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_21():
    result = parse("B*38:21")
    assert result.__class__ is Allele, f'Expected parse("B*38:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_22():
    result = parse("B*38:22")
    assert result.__class__ is Allele, f'Expected parse("B*38:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_23():
    result = parse("B*38:23")
    assert result.__class__ is Allele, f'Expected parse("B*38:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_24():
    result = parse("B*38:24")
    assert result.__class__ is Allele, f'Expected parse("B*38:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_25():
    result = parse("B*38:25")
    assert result.__class__ is Allele, f'Expected parse("B*38:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_26():
    result = parse("B*38:26")
    assert result.__class__ is Allele, f'Expected parse("B*38:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_27():
    result = parse("B*38:27")
    assert result.__class__ is Allele, f'Expected parse("B*38:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_28():
    result = parse("B*38:28")
    assert result.__class__ is Allele, f'Expected parse("B*38:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_29():
    result = parse("B*38:29")
    assert result.__class__ is Allele, f'Expected parse("B*38:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_30():
    result = parse("B*38:30")
    assert result.__class__ is Allele, f'Expected parse("B*38:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_31():
    result = parse("B*38:31")
    assert result.__class__ is Allele, f'Expected parse("B*38:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_32():
    result = parse("B*38:32")
    assert result.__class__ is Allele, f'Expected parse("B*38:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_33():
    result = parse("B*38:33")
    assert result.__class__ is Allele, f'Expected parse("B*38:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_34N():
    result = parse("B*38:34N")
    assert result.__class__ is Allele, f'Expected parse("B*38:34N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:34N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_35():
    result = parse("B*38:35")
    assert result.__class__ is Allele, f'Expected parse("B*38:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_36():
    result = parse("B*38:36")
    assert result.__class__ is Allele, f'Expected parse("B*38:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_37():
    result = parse("B*38:37")
    assert result.__class__ is Allele, f'Expected parse("B*38:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_38():
    result = parse("B*38:38")
    assert result.__class__ is Allele, f'Expected parse("B*38:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_39():
    result = parse("B*38:39")
    assert result.__class__ is Allele, f'Expected parse("B*38:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_40():
    result = parse("B*38:40")
    assert result.__class__ is Allele, f'Expected parse("B*38:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_41():
    result = parse("B*38:41")
    assert result.__class__ is Allele, f'Expected parse("B*38:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_42():
    result = parse("B*38:42")
    assert result.__class__ is Allele, f'Expected parse("B*38:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_43():
    result = parse("B*38:43")
    assert result.__class__ is Allele, f'Expected parse("B*38:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_44():
    result = parse("B*38:44")
    assert result.__class__ is Allele, f'Expected parse("B*38:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_45():
    result = parse("B*38:45")
    assert result.__class__ is Allele, f'Expected parse("B*38:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_46():
    result = parse("B*38:46")
    assert result.__class__ is Allele, f'Expected parse("B*38:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_47():
    result = parse("B*38:47")
    assert result.__class__ is Allele, f'Expected parse("B*38:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_48():
    result = parse("B*38:48")
    assert result.__class__ is Allele, f'Expected parse("B*38:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_49():
    result = parse("B*38:49")
    assert result.__class__ is Allele, f'Expected parse("B*38:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_50():
    result = parse("B*38:50")
    assert result.__class__ is Allele, f'Expected parse("B*38:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_51():
    result = parse("B*38:51")
    assert result.__class__ is Allele, f'Expected parse("B*38:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_52():
    result = parse("B*38:52")
    assert result.__class__ is Allele, f'Expected parse("B*38:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_53():
    result = parse("B*38:53")
    assert result.__class__ is Allele, f'Expected parse("B*38:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_54():
    result = parse("B*38:54")
    assert result.__class__ is Allele, f'Expected parse("B*38:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_55Q():
    result = parse("B*38:55Q")
    assert result.__class__ is Allele, f'Expected parse("B*38:55Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:55Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_56():
    result = parse("B*38:56")
    assert result.__class__ is Allele, f'Expected parse("B*38:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_57():
    result = parse("B*38:57")
    assert result.__class__ is Allele, f'Expected parse("B*38:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_58():
    result = parse("B*38:58")
    assert result.__class__ is Allele, f'Expected parse("B*38:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_59():
    result = parse("B*38:59")
    assert result.__class__ is Allele, f'Expected parse("B*38:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_60():
    result = parse("B*38:60")
    assert result.__class__ is Allele, f'Expected parse("B*38:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_61():
    result = parse("B*38:61")
    assert result.__class__ is Allele, f'Expected parse("B*38:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_62():
    result = parse("B*38:62")
    assert result.__class__ is Allele, f'Expected parse("B*38:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_63():
    result = parse("B*38:63")
    assert result.__class__ is Allele, f'Expected parse("B*38:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_64():
    result = parse("B*38:64")
    assert result.__class__ is Allele, f'Expected parse("B*38:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_65():
    result = parse("B*38:65")
    assert result.__class__ is Allele, f'Expected parse("B*38:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_66():
    result = parse("B*38:66")
    assert result.__class__ is Allele, f'Expected parse("B*38:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_67():
    result = parse("B*38:67")
    assert result.__class__ is Allele, f'Expected parse("B*38:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_68L():
    result = parse("B*38:68L")
    assert result.__class__ is Allele, f'Expected parse("B*38:68L") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:68L") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_69():
    result = parse("B*38:69")
    assert result.__class__ is Allele, f'Expected parse("B*38:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_70():
    result = parse("B*38:70")
    assert result.__class__ is Allele, f'Expected parse("B*38:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_71():
    result = parse("B*38:71")
    assert result.__class__ is Allele, f'Expected parse("B*38:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_72():
    result = parse("B*38:72")
    assert result.__class__ is Allele, f'Expected parse("B*38:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_73():
    result = parse("B*38:73")
    assert result.__class__ is Allele, f'Expected parse("B*38:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_74():
    result = parse("B*38:74")
    assert result.__class__ is Allele, f'Expected parse("B*38:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_75():
    result = parse("B*38:75")
    assert result.__class__ is Allele, f'Expected parse("B*38:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_76():
    result = parse("B*38:76")
    assert result.__class__ is Allele, f'Expected parse("B*38:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_77():
    result = parse("B*38:77")
    assert result.__class__ is Allele, f'Expected parse("B*38:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_78():
    result = parse("B*38:78")
    assert result.__class__ is Allele, f'Expected parse("B*38:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_79():
    result = parse("B*38:79")
    assert result.__class__ is Allele, f'Expected parse("B*38:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_80N():
    result = parse("B*38:80N")
    assert result.__class__ is Allele, f'Expected parse("B*38:80N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:80N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_81():
    result = parse("B*38:81")
    assert result.__class__ is Allele, f'Expected parse("B*38:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_82():
    result = parse("B*38:82")
    assert result.__class__ is Allele, f'Expected parse("B*38:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_83N():
    result = parse("B*38:83N")
    assert result.__class__ is Allele, f'Expected parse("B*38:83N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:83N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_84():
    result = parse("B*38:84")
    assert result.__class__ is Allele, f'Expected parse("B*38:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_85():
    result = parse("B*38:85")
    assert result.__class__ is Allele, f'Expected parse("B*38:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_38_86():
    result = parse("B*38:86")
    assert result.__class__ is Allele, f'Expected parse("B*38:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*38:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_01_01():
    result = parse("B*39:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_01_02L():
    result = parse("B*39:01:01:02L")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:01:01:02L") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:01:01:02L") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_01_03():
    result = parse("B*39:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_01_04():
    result = parse("B*39:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_01_05():
    result = parse("B*39:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_01_06():
    result = parse("B*39:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_01_07():
    result = parse("B*39:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_01_08():
    result = parse("B*39:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_01_09():
    result = parse("B*39:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_01_10():
    result = parse("B*39:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_01_11():
    result = parse("B*39:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_01_12():
    result = parse("B*39:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_01_13():
    result = parse("B*39:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_01_14():
    result = parse("B*39:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_03_01():
    result = parse("B*39:01:03:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:01:03:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:01:03:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_03_02():
    result = parse("B*39:01:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:01:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:01:03:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_04():
    result = parse("B*39:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_05():
    result = parse("B*39:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_06():
    result = parse("B*39:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_07():
    result = parse("B*39:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_08():
    result = parse("B*39:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_09():
    result = parse("B*39:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_10():
    result = parse("B*39:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_11():
    result = parse("B*39:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_12():
    result = parse("B*39:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_13():
    result = parse("B*39:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_14():
    result = parse("B*39:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_15():
    result = parse("B*39:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_16():
    result = parse("B*39:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_17():
    result = parse("B*39:01:17")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_18():
    result = parse("B*39:01:18")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_19():
    result = parse("B*39:01:19")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_20():
    result = parse("B*39:01:20")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_21():
    result = parse("B*39:01:21")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_22():
    result = parse("B*39:01:22")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_23():
    result = parse("B*39:01:23")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_24():
    result = parse("B*39:01:24")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_25():
    result = parse("B*39:01:25")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_26():
    result = parse("B*39:01:26")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_27():
    result = parse("B*39:01:27")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_28():
    result = parse("B*39:01:28")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_29():
    result = parse("B*39:01:29")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_30():
    result = parse("B*39:01:30")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_31():
    result = parse("B*39:01:31")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_01_32():
    result = parse("B*39:01:32")
    assert result.__class__ is Allele, f'Expected parse("B*39:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_02_01_01():
    result = parse("B*39:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_02_01_02():
    result = parse("B*39:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_02_02_01():
    result = parse("B*39:02:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:02:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:02:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_02_02_02():
    result = parse("B*39:02:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:02:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:02:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_02_02_03():
    result = parse("B*39:02:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:02:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:02:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_02_02_04():
    result = parse("B*39:02:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:02:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:02:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_02_03():
    result = parse("B*39:02:03")
    assert result.__class__ is Allele, f'Expected parse("B*39:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_03_01_01():
    result = parse("B*39:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_03_01_02():
    result = parse("B*39:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_03_01_03():
    result = parse("B*39:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_04():
    result = parse("B*39:04")
    assert result.__class__ is Allele, f'Expected parse("B*39:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_05_01_01():
    result = parse("B*39:05:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:05:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:05:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_05_01_02():
    result = parse("B*39:05:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:05:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:05:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_05_01_03():
    result = parse("B*39:05:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:05:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:05:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_05_01_04():
    result = parse("B*39:05:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:05:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:05:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_05_02():
    result = parse("B*39:05:02")
    assert result.__class__ is Allele, f'Expected parse("B*39:05:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_05_03():
    result = parse("B*39:05:03")
    assert result.__class__ is Allele, f'Expected parse("B*39:05:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:05:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_06_01():
    result = parse("B*39:06:01")
    assert result.__class__ is Allele, f'Expected parse("B*39:06:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_06_02_01():
    result = parse("B*39:06:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:06:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:06:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_06_02_02():
    result = parse("B*39:06:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:06:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:06:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_06_02_03():
    result = parse("B*39:06:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:06:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:06:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_06_02_04():
    result = parse("B*39:06:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:06:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:06:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_06_02_05():
    result = parse("B*39:06:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:06:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:06:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_06_02_06():
    result = parse("B*39:06:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:06:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:06:02:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_06_02_07():
    result = parse("B*39:06:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:06:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:06:02:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_06_03():
    result = parse("B*39:06:03")
    assert result.__class__ is Allele, f'Expected parse("B*39:06:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:06:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_06_04():
    result = parse("B*39:06:04")
    assert result.__class__ is Allele, f'Expected parse("B*39:06:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:06:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_06_05():
    result = parse("B*39:06:05")
    assert result.__class__ is Allele, f'Expected parse("B*39:06:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:06:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_06_06():
    result = parse("B*39:06:06")
    assert result.__class__ is Allele, f'Expected parse("B*39:06:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:06:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_07():
    result = parse("B*39:07")
    assert result.__class__ is Allele, f'Expected parse("B*39:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_08():
    result = parse("B*39:08")
    assert result.__class__ is Allele, f'Expected parse("B*39:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_09_01_01():
    result = parse("B*39:09:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:09:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:09:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_09_01_02():
    result = parse("B*39:09:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:09:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:09:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_09_01_03():
    result = parse("B*39:09:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:09:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:09:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_09_01_04():
    result = parse("B*39:09:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:09:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:09:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_09_02():
    result = parse("B*39:09:02")
    assert result.__class__ is Allele, f'Expected parse("B*39:09:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:09:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_09_03():
    result = parse("B*39:09:03")
    assert result.__class__ is Allele, f'Expected parse("B*39:09:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:09:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_09_04():
    result = parse("B*39:09:04")
    assert result.__class__ is Allele, f'Expected parse("B*39:09:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:09:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_100():
    result = parse("B*39:100")
    assert result.__class__ is Allele, f'Expected parse("B*39:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_101():
    result = parse("B*39:101")
    assert result.__class__ is Allele, f'Expected parse("B*39:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_102():
    result = parse("B*39:102")
    assert result.__class__ is Allele, f'Expected parse("B*39:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_103():
    result = parse("B*39:103")
    assert result.__class__ is Allele, f'Expected parse("B*39:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_104():
    result = parse("B*39:104")
    assert result.__class__ is Allele, f'Expected parse("B*39:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_105():
    result = parse("B*39:105")
    assert result.__class__ is Allele, f'Expected parse("B*39:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_106():
    result = parse("B*39:106")
    assert result.__class__ is Allele, f'Expected parse("B*39:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_107():
    result = parse("B*39:107")
    assert result.__class__ is Allele, f'Expected parse("B*39:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_108():
    result = parse("B*39:108")
    assert result.__class__ is Allele, f'Expected parse("B*39:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_109():
    result = parse("B*39:109")
    assert result.__class__ is Allele, f'Expected parse("B*39:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_10_01():
    result = parse("B*39:10:01")
    assert result.__class__ is Allele, f'Expected parse("B*39:10:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:10:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_10_02():
    result = parse("B*39:10:02")
    assert result.__class__ is Allele, f'Expected parse("B*39:10:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:10:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_11():
    result = parse("B*39:11")
    assert result.__class__ is Allele, f'Expected parse("B*39:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_110():
    result = parse("B*39:110")
    assert result.__class__ is Allele, f'Expected parse("B*39:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_111():
    result = parse("B*39:111")
    assert result.__class__ is Allele, f'Expected parse("B*39:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_112():
    result = parse("B*39:112")
    assert result.__class__ is Allele, f'Expected parse("B*39:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_113():
    result = parse("B*39:113")
    assert result.__class__ is Allele, f'Expected parse("B*39:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_114():
    result = parse("B*39:114")
    assert result.__class__ is Allele, f'Expected parse("B*39:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_115():
    result = parse("B*39:115")
    assert result.__class__ is Allele, f'Expected parse("B*39:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_116N():
    result = parse("B*39:116N")
    assert result.__class__ is Allele, f'Expected parse("B*39:116N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:116N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_117():
    result = parse("B*39:117")
    assert result.__class__ is Allele, f'Expected parse("B*39:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_118():
    result = parse("B*39:118")
    assert result.__class__ is Allele, f'Expected parse("B*39:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_119():
    result = parse("B*39:119")
    assert result.__class__ is Allele, f'Expected parse("B*39:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_120():
    result = parse("B*39:120")
    assert result.__class__ is Allele, f'Expected parse("B*39:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_121():
    result = parse("B*39:121")
    assert result.__class__ is Allele, f'Expected parse("B*39:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_122():
    result = parse("B*39:122")
    assert result.__class__ is Allele, f'Expected parse("B*39:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_123():
    result = parse("B*39:123")
    assert result.__class__ is Allele, f'Expected parse("B*39:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_124():
    result = parse("B*39:124")
    assert result.__class__ is Allele, f'Expected parse("B*39:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_125():
    result = parse("B*39:125")
    assert result.__class__ is Allele, f'Expected parse("B*39:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_126():
    result = parse("B*39:126")
    assert result.__class__ is Allele, f'Expected parse("B*39:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_127():
    result = parse("B*39:127")
    assert result.__class__ is Allele, f'Expected parse("B*39:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_128():
    result = parse("B*39:128")
    assert result.__class__ is Allele, f'Expected parse("B*39:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_129():
    result = parse("B*39:129")
    assert result.__class__ is Allele, f'Expected parse("B*39:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_12_01_01():
    result = parse("B*39:12:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:12:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:12:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_12_01_02():
    result = parse("B*39:12:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:12:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:12:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_130():
    result = parse("B*39:130")
    assert result.__class__ is Allele, f'Expected parse("B*39:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_131():
    result = parse("B*39:131")
    assert result.__class__ is Allele, f'Expected parse("B*39:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_132():
    result = parse("B*39:132")
    assert result.__class__ is Allele, f'Expected parse("B*39:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_133N():
    result = parse("B*39:133N")
    assert result.__class__ is Allele, f'Expected parse("B*39:133N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:133N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_134():
    result = parse("B*39:134")
    assert result.__class__ is Allele, f'Expected parse("B*39:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_135():
    result = parse("B*39:135")
    assert result.__class__ is Allele, f'Expected parse("B*39:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_136():
    result = parse("B*39:136")
    assert result.__class__ is Allele, f'Expected parse("B*39:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_137():
    result = parse("B*39:137")
    assert result.__class__ is Allele, f'Expected parse("B*39:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_138():
    result = parse("B*39:138")
    assert result.__class__ is Allele, f'Expected parse("B*39:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_139N():
    result = parse("B*39:139N")
    assert result.__class__ is Allele, f'Expected parse("B*39:139N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:139N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_13_01():
    result = parse("B*39:13:01")
    assert result.__class__ is Allele, f'Expected parse("B*39:13:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:13:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_13_02():
    result = parse("B*39:13:02")
    assert result.__class__ is Allele, f'Expected parse("B*39:13:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:13:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_140():
    result = parse("B*39:140")
    assert result.__class__ is Allele, f'Expected parse("B*39:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_141():
    result = parse("B*39:141")
    assert result.__class__ is Allele, f'Expected parse("B*39:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_142N():
    result = parse("B*39:142N")
    assert result.__class__ is Allele, f'Expected parse("B*39:142N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:142N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_143():
    result = parse("B*39:143")
    assert result.__class__ is Allele, f'Expected parse("B*39:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_144():
    result = parse("B*39:144")
    assert result.__class__ is Allele, f'Expected parse("B*39:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_145():
    result = parse("B*39:145")
    assert result.__class__ is Allele, f'Expected parse("B*39:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_146N():
    result = parse("B*39:146N")
    assert result.__class__ is Allele, f'Expected parse("B*39:146N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:146N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_147N():
    result = parse("B*39:147N")
    assert result.__class__ is Allele, f'Expected parse("B*39:147N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:147N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_148():
    result = parse("B*39:148")
    assert result.__class__ is Allele, f'Expected parse("B*39:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_149():
    result = parse("B*39:149")
    assert result.__class__ is Allele, f'Expected parse("B*39:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_14_01_01():
    result = parse("B*39:14:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:14:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:14:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_14_01_02():
    result = parse("B*39:14:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:14:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:14:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_14_01_03():
    result = parse("B*39:14:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:14:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:14:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_15():
    result = parse("B*39:15")
    assert result.__class__ is Allele, f'Expected parse("B*39:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_150Q():
    result = parse("B*39:150Q")
    assert result.__class__ is Allele, f'Expected parse("B*39:150Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:150Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_151():
    result = parse("B*39:151")
    assert result.__class__ is Allele, f'Expected parse("B*39:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_152():
    result = parse("B*39:152")
    assert result.__class__ is Allele, f'Expected parse("B*39:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_153():
    result = parse("B*39:153")
    assert result.__class__ is Allele, f'Expected parse("B*39:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_154():
    result = parse("B*39:154")
    assert result.__class__ is Allele, f'Expected parse("B*39:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_155():
    result = parse("B*39:155")
    assert result.__class__ is Allele, f'Expected parse("B*39:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_156():
    result = parse("B*39:156")
    assert result.__class__ is Allele, f'Expected parse("B*39:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_157N():
    result = parse("B*39:157N")
    assert result.__class__ is Allele, f'Expected parse("B*39:157N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:157N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_158():
    result = parse("B*39:158")
    assert result.__class__ is Allele, f'Expected parse("B*39:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_159():
    result = parse("B*39:159")
    assert result.__class__ is Allele, f'Expected parse("B*39:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_16():
    result = parse("B*39:16")
    assert result.__class__ is Allele, f'Expected parse("B*39:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_160():
    result = parse("B*39:160")
    assert result.__class__ is Allele, f'Expected parse("B*39:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_161N():
    result = parse("B*39:161N")
    assert result.__class__ is Allele, f'Expected parse("B*39:161N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:161N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_162():
    result = parse("B*39:162")
    assert result.__class__ is Allele, f'Expected parse("B*39:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_163():
    result = parse("B*39:163")
    assert result.__class__ is Allele, f'Expected parse("B*39:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_164():
    result = parse("B*39:164")
    assert result.__class__ is Allele, f'Expected parse("B*39:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_165():
    result = parse("B*39:165")
    assert result.__class__ is Allele, f'Expected parse("B*39:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_166():
    result = parse("B*39:166")
    assert result.__class__ is Allele, f'Expected parse("B*39:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_167():
    result = parse("B*39:167")
    assert result.__class__ is Allele, f'Expected parse("B*39:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_168():
    result = parse("B*39:168")
    assert result.__class__ is Allele, f'Expected parse("B*39:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_17():
    result = parse("B*39:17")
    assert result.__class__ is Allele, f'Expected parse("B*39:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_18():
    result = parse("B*39:18")
    assert result.__class__ is Allele, f'Expected parse("B*39:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_19_01():
    result = parse("B*39:19:01")
    assert result.__class__ is Allele, f'Expected parse("B*39:19:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:19:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_19_02():
    result = parse("B*39:19:02")
    assert result.__class__ is Allele, f'Expected parse("B*39:19:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:19:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_20():
    result = parse("B*39:20")
    assert result.__class__ is Allele, f'Expected parse("B*39:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_22():
    result = parse("B*39:22")
    assert result.__class__ is Allele, f'Expected parse("B*39:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_23():
    result = parse("B*39:23")
    assert result.__class__ is Allele, f'Expected parse("B*39:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_24_01():
    result = parse("B*39:24:01")
    assert result.__class__ is Allele, f'Expected parse("B*39:24:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:24:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_24_02():
    result = parse("B*39:24:02")
    assert result.__class__ is Allele, f'Expected parse("B*39:24:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:24:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_25N():
    result = parse("B*39:25N")
    assert result.__class__ is Allele, f'Expected parse("B*39:25N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:25N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_26():
    result = parse("B*39:26")
    assert result.__class__ is Allele, f'Expected parse("B*39:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_27():
    result = parse("B*39:27")
    assert result.__class__ is Allele, f'Expected parse("B*39:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_28():
    result = parse("B*39:28")
    assert result.__class__ is Allele, f'Expected parse("B*39:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_29():
    result = parse("B*39:29")
    assert result.__class__ is Allele, f'Expected parse("B*39:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_30():
    result = parse("B*39:30")
    assert result.__class__ is Allele, f'Expected parse("B*39:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_31_01_01():
    result = parse("B*39:31:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:31:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:31:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_31_01_02():
    result = parse("B*39:31:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:31:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:31:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_32():
    result = parse("B*39:32")
    assert result.__class__ is Allele, f'Expected parse("B*39:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_33():
    result = parse("B*39:33")
    assert result.__class__ is Allele, f'Expected parse("B*39:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_34():
    result = parse("B*39:34")
    assert result.__class__ is Allele, f'Expected parse("B*39:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_35():
    result = parse("B*39:35")
    assert result.__class__ is Allele, f'Expected parse("B*39:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_36():
    result = parse("B*39:36")
    assert result.__class__ is Allele, f'Expected parse("B*39:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_37_01_01():
    result = parse("B*39:37:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:37:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:37:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_37_01_02():
    result = parse("B*39:37:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:37:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*39:37:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_38Q():
    result = parse("B*39:38Q")
    assert result.__class__ is Allele, f'Expected parse("B*39:38Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:38Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_39_01():
    result = parse("B*39:39:01")
    assert result.__class__ is Allele, f'Expected parse("B*39:39:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:39:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_39_02():
    result = parse("B*39:39:02")
    assert result.__class__ is Allele, f'Expected parse("B*39:39:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:39:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_40_01N():
    result = parse("B*39:40:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:40:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:40:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_40_02N():
    result = parse("B*39:40:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("B*39:40:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:40:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_41():
    result = parse("B*39:41")
    assert result.__class__ is Allele, f'Expected parse("B*39:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_42():
    result = parse("B*39:42")
    assert result.__class__ is Allele, f'Expected parse("B*39:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_43():
    result = parse("B*39:43")
    assert result.__class__ is Allele, f'Expected parse("B*39:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_44():
    result = parse("B*39:44")
    assert result.__class__ is Allele, f'Expected parse("B*39:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_45():
    result = parse("B*39:45")
    assert result.__class__ is Allele, f'Expected parse("B*39:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_46():
    result = parse("B*39:46")
    assert result.__class__ is Allele, f'Expected parse("B*39:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_47():
    result = parse("B*39:47")
    assert result.__class__ is Allele, f'Expected parse("B*39:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_48():
    result = parse("B*39:48")
    assert result.__class__ is Allele, f'Expected parse("B*39:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_49():
    result = parse("B*39:49")
    assert result.__class__ is Allele, f'Expected parse("B*39:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_50():
    result = parse("B*39:50")
    assert result.__class__ is Allele, f'Expected parse("B*39:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_51():
    result = parse("B*39:51")
    assert result.__class__ is Allele, f'Expected parse("B*39:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_52():
    result = parse("B*39:52")
    assert result.__class__ is Allele, f'Expected parse("B*39:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_53():
    result = parse("B*39:53")
    assert result.__class__ is Allele, f'Expected parse("B*39:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_54():
    result = parse("B*39:54")
    assert result.__class__ is Allele, f'Expected parse("B*39:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_55():
    result = parse("B*39:55")
    assert result.__class__ is Allele, f'Expected parse("B*39:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_56():
    result = parse("B*39:56")
    assert result.__class__ is Allele, f'Expected parse("B*39:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_57():
    result = parse("B*39:57")
    assert result.__class__ is Allele, f'Expected parse("B*39:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_58():
    result = parse("B*39:58")
    assert result.__class__ is Allele, f'Expected parse("B*39:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_59():
    result = parse("B*39:59")
    assert result.__class__ is Allele, f'Expected parse("B*39:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_60():
    result = parse("B*39:60")
    assert result.__class__ is Allele, f'Expected parse("B*39:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_61():
    result = parse("B*39:61")
    assert result.__class__ is Allele, f'Expected parse("B*39:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_62():
    result = parse("B*39:62")
    assert result.__class__ is Allele, f'Expected parse("B*39:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_63():
    result = parse("B*39:63")
    assert result.__class__ is Allele, f'Expected parse("B*39:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_64():
    result = parse("B*39:64")
    assert result.__class__ is Allele, f'Expected parse("B*39:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_65():
    result = parse("B*39:65")
    assert result.__class__ is Allele, f'Expected parse("B*39:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_66():
    result = parse("B*39:66")
    assert result.__class__ is Allele, f'Expected parse("B*39:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_67():
    result = parse("B*39:67")
    assert result.__class__ is Allele, f'Expected parse("B*39:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_68():
    result = parse("B*39:68")
    assert result.__class__ is Allele, f'Expected parse("B*39:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_69():
    result = parse("B*39:69")
    assert result.__class__ is Allele, f'Expected parse("B*39:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_70():
    result = parse("B*39:70")
    assert result.__class__ is Allele, f'Expected parse("B*39:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_71():
    result = parse("B*39:71")
    assert result.__class__ is Allele, f'Expected parse("B*39:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_72():
    result = parse("B*39:72")
    assert result.__class__ is Allele, f'Expected parse("B*39:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_73():
    result = parse("B*39:73")
    assert result.__class__ is Allele, f'Expected parse("B*39:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_74():
    result = parse("B*39:74")
    assert result.__class__ is Allele, f'Expected parse("B*39:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_75():
    result = parse("B*39:75")
    assert result.__class__ is Allele, f'Expected parse("B*39:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_76():
    result = parse("B*39:76")
    assert result.__class__ is Allele, f'Expected parse("B*39:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_77():
    result = parse("B*39:77")
    assert result.__class__ is Allele, f'Expected parse("B*39:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_78():
    result = parse("B*39:78")
    assert result.__class__ is Allele, f'Expected parse("B*39:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_79():
    result = parse("B*39:79")
    assert result.__class__ is Allele, f'Expected parse("B*39:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_80():
    result = parse("B*39:80")
    assert result.__class__ is Allele, f'Expected parse("B*39:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_81():
    result = parse("B*39:81")
    assert result.__class__ is Allele, f'Expected parse("B*39:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_82():
    result = parse("B*39:82")
    assert result.__class__ is Allele, f'Expected parse("B*39:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_83_01():
    result = parse("B*39:83:01")
    assert result.__class__ is Allele, f'Expected parse("B*39:83:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:83:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_83_02():
    result = parse("B*39:83:02")
    assert result.__class__ is Allele, f'Expected parse("B*39:83:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:83:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_83_03():
    result = parse("B*39:83:03")
    assert result.__class__ is Allele, f'Expected parse("B*39:83:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*39:83:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_84():
    result = parse("B*39:84")
    assert result.__class__ is Allele, f'Expected parse("B*39:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_85():
    result = parse("B*39:85")
    assert result.__class__ is Allele, f'Expected parse("B*39:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_86():
    result = parse("B*39:86")
    assert result.__class__ is Allele, f'Expected parse("B*39:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_87N():
    result = parse("B*39:87N")
    assert result.__class__ is Allele, f'Expected parse("B*39:87N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:87N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_88():
    result = parse("B*39:88")
    assert result.__class__ is Allele, f'Expected parse("B*39:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_89():
    result = parse("B*39:89")
    assert result.__class__ is Allele, f'Expected parse("B*39:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_90():
    result = parse("B*39:90")
    assert result.__class__ is Allele, f'Expected parse("B*39:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_91():
    result = parse("B*39:91")
    assert result.__class__ is Allele, f'Expected parse("B*39:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_92():
    result = parse("B*39:92")
    assert result.__class__ is Allele, f'Expected parse("B*39:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_93():
    result = parse("B*39:93")
    assert result.__class__ is Allele, f'Expected parse("B*39:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_94():
    result = parse("B*39:94")
    assert result.__class__ is Allele, f'Expected parse("B*39:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_95N():
    result = parse("B*39:95N")
    assert result.__class__ is Allele, f'Expected parse("B*39:95N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:95N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_96():
    result = parse("B*39:96")
    assert result.__class__ is Allele, f'Expected parse("B*39:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_97N():
    result = parse("B*39:97N")
    assert result.__class__ is Allele, f'Expected parse("B*39:97N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:97N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_98():
    result = parse("B*39:98")
    assert result.__class__ is Allele, f'Expected parse("B*39:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_39_99():
    result = parse("B*39:99")
    assert result.__class__ is Allele, f'Expected parse("B*39:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*39:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_01():
    result = parse("B*40:01:01")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_01():
    result = parse("B*40:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_02():
    result = parse("B*40:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_03():
    result = parse("B*40:01:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_04():
    result = parse("B*40:01:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_05():
    result = parse("B*40:01:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_06():
    result = parse("B*40:01:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_07():
    result = parse("B*40:01:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_08():
    result = parse("B*40:01:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_09():
    result = parse("B*40:01:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_10():
    result = parse("B*40:01:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_11():
    result = parse("B*40:01:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_12():
    result = parse("B*40:01:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_13():
    result = parse("B*40:01:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_14():
    result = parse("B*40:01:02:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_15():
    result = parse("B*40:01:02:15")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_16():
    result = parse("B*40:01:02:16")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_17():
    result = parse("B*40:01:02:17")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_18():
    result = parse("B*40:01:02:18")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_19():
    result = parse("B*40:01:02:19")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_20():
    result = parse("B*40:01:02:20")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_21():
    result = parse("B*40:01:02:21")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_22():
    result = parse("B*40:01:02:22")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_23():
    result = parse("B*40:01:02:23")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_24():
    result = parse("B*40:01:02:24")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_25():
    result = parse("B*40:01:02:25")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_26():
    result = parse("B*40:01:02:26")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_27():
    result = parse("B*40:01:02:27")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_28():
    result = parse("B*40:01:02:28")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_29():
    result = parse("B*40:01:02:29")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_30():
    result = parse("B*40:01:02:30")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_31():
    result = parse("B*40:01:02:31")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_32():
    result = parse("B*40:01:02:32")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_33():
    result = parse("B*40:01:02:33")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_02_34():
    result = parse("B*40:01:02:34")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:01:02:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:01:02:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_03():
    result = parse("B*40:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_04():
    result = parse("B*40:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_05():
    result = parse("B*40:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_06():
    result = parse("B*40:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_07():
    result = parse("B*40:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_08():
    result = parse("B*40:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_09():
    result = parse("B*40:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_10():
    result = parse("B*40:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_11():
    result = parse("B*40:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_12():
    result = parse("B*40:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_13():
    result = parse("B*40:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_14():
    result = parse("B*40:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_15():
    result = parse("B*40:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_16():
    result = parse("B*40:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_17():
    result = parse("B*40:01:17")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_18():
    result = parse("B*40:01:18")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_19():
    result = parse("B*40:01:19")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_20():
    result = parse("B*40:01:20")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_21():
    result = parse("B*40:01:21")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_22():
    result = parse("B*40:01:22")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_23():
    result = parse("B*40:01:23")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_24():
    result = parse("B*40:01:24")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_25():
    result = parse("B*40:01:25")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_26():
    result = parse("B*40:01:26")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_27():
    result = parse("B*40:01:27")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_28():
    result = parse("B*40:01:28")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_29():
    result = parse("B*40:01:29")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_30():
    result = parse("B*40:01:30")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_31():
    result = parse("B*40:01:31")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_32():
    result = parse("B*40:01:32")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_33():
    result = parse("B*40:01:33")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_34():
    result = parse("B*40:01:34")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_35():
    result = parse("B*40:01:35")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_36():
    result = parse("B*40:01:36")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_37():
    result = parse("B*40:01:37")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_38():
    result = parse("B*40:01:38")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_39():
    result = parse("B*40:01:39")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_40():
    result = parse("B*40:01:40")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_41():
    result = parse("B*40:01:41")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_42():
    result = parse("B*40:01:42")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_43():
    result = parse("B*40:01:43")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_44():
    result = parse("B*40:01:44")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_45():
    result = parse("B*40:01:45")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_46():
    result = parse("B*40:01:46")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_47():
    result = parse("B*40:01:47")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_48():
    result = parse("B*40:01:48")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_49():
    result = parse("B*40:01:49")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_50():
    result = parse("B*40:01:50")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_51():
    result = parse("B*40:01:51")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_52():
    result = parse("B*40:01:52")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_53():
    result = parse("B*40:01:53")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_54():
    result = parse("B*40:01:54")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_55():
    result = parse("B*40:01:55")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_56():
    result = parse("B*40:01:56")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_57():
    result = parse("B*40:01:57")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_58():
    result = parse("B*40:01:58")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_59():
    result = parse("B*40:01:59")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_60():
    result = parse("B*40:01:60")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_61():
    result = parse("B*40:01:61")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_62():
    result = parse("B*40:01:62")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_63():
    result = parse("B*40:01:63")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_64():
    result = parse("B*40:01:64")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_65():
    result = parse("B*40:01:65")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_66():
    result = parse("B*40:01:66")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:66") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:66") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_67():
    result = parse("B*40:01:67")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:67") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:67") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_68():
    result = parse("B*40:01:68")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:68") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:68") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_69():
    result = parse("B*40:01:69")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:69") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:69") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_01_70():
    result = parse("B*40:01:70")
    assert result.__class__ is Allele, f'Expected parse("B*40:01:70") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:01:70") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_01():
    result = parse("B*40:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_02():
    result = parse("B*40:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_03():
    result = parse("B*40:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_04():
    result = parse("B*40:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_05():
    result = parse("B*40:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_06():
    result = parse("B*40:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_07():
    result = parse("B*40:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_08():
    result = parse("B*40:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_09():
    result = parse("B*40:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_10():
    result = parse("B*40:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_11():
    result = parse("B*40:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_12():
    result = parse("B*40:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_13():
    result = parse("B*40:02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_14():
    result = parse("B*40:02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_15():
    result = parse("B*40:02:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_16():
    result = parse("B*40:02:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_17():
    result = parse("B*40:02:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_01_18():
    result = parse("B*40:02:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:02:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:02:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_02():
    result = parse("B*40:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_03():
    result = parse("B*40:02:03")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_04():
    result = parse("B*40:02:04")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_05():
    result = parse("B*40:02:05")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_06():
    result = parse("B*40:02:06")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_07():
    result = parse("B*40:02:07")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_08():
    result = parse("B*40:02:08")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_09():
    result = parse("B*40:02:09")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_10():
    result = parse("B*40:02:10")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_11():
    result = parse("B*40:02:11")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_12():
    result = parse("B*40:02:12")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_13():
    result = parse("B*40:02:13")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_14():
    result = parse("B*40:02:14")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_15():
    result = parse("B*40:02:15")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_16():
    result = parse("B*40:02:16")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_17():
    result = parse("B*40:02:17")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_18():
    result = parse("B*40:02:18")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_19():
    result = parse("B*40:02:19")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_20():
    result = parse("B*40:02:20")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_21():
    result = parse("B*40:02:21")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_22():
    result = parse("B*40:02:22")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_23():
    result = parse("B*40:02:23")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_24():
    result = parse("B*40:02:24")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_25():
    result = parse("B*40:02:25")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_26():
    result = parse("B*40:02:26")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_27():
    result = parse("B*40:02:27")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_28():
    result = parse("B*40:02:28")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_29():
    result = parse("B*40:02:29")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_30():
    result = parse("B*40:02:30")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_02_31():
    result = parse("B*40:02:31")
    assert result.__class__ is Allele, f'Expected parse("B*40:02:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:02:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_03_01_01():
    result = parse("B*40:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_03_01_02():
    result = parse("B*40:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_03_02():
    result = parse("B*40:03:02")
    assert result.__class__ is Allele, f'Expected parse("B*40:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_04_01():
    result = parse("B*40:04:01")
    assert result.__class__ is Allele, f'Expected parse("B*40:04:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_04_02():
    result = parse("B*40:04:02")
    assert result.__class__ is Allele, f'Expected parse("B*40:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_05_01_01():
    result = parse("B*40:05:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:05:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:05:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_05_01_02():
    result = parse("B*40:05:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:05:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:05:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_05_01_03():
    result = parse("B*40:05:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:05:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:05:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_01_01():
    result = parse("B*40:06:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:06:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:06:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_01_02():
    result = parse("B*40:06:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:06:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:06:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_01_03():
    result = parse("B*40:06:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:06:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:06:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_01_04():
    result = parse("B*40:06:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:06:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:06:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_01_05():
    result = parse("B*40:06:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:06:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:06:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_01_06():
    result = parse("B*40:06:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:06:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:06:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_01_07():
    result = parse("B*40:06:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:06:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:06:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_01_08():
    result = parse("B*40:06:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:06:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:06:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_01_09():
    result = parse("B*40:06:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:06:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:06:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_01_10():
    result = parse("B*40:06:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:06:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:06:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_01_11():
    result = parse("B*40:06:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:06:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:06:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_01_12():
    result = parse("B*40:06:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:06:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:06:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_02():
    result = parse("B*40:06:02")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_03():
    result = parse("B*40:06:03")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_04_01():
    result = parse("B*40:06:04:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:06:04:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:06:04:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_04_02():
    result = parse("B*40:06:04:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:06:04:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:06:04:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_04_03():
    result = parse("B*40:06:04:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:06:04:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:06:04:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_05():
    result = parse("B*40:06:05")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_06():
    result = parse("B*40:06:06")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_07():
    result = parse("B*40:06:07")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_08():
    result = parse("B*40:06:08")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_09():
    result = parse("B*40:06:09")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_10():
    result = parse("B*40:06:10")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_11():
    result = parse("B*40:06:11")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_12():
    result = parse("B*40:06:12")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_13():
    result = parse("B*40:06:13")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_14():
    result = parse("B*40:06:14")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_15():
    result = parse("B*40:06:15")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_16():
    result = parse("B*40:06:16")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_17():
    result = parse("B*40:06:17")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_18():
    result = parse("B*40:06:18")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_19():
    result = parse("B*40:06:19")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_20():
    result = parse("B*40:06:20")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_21():
    result = parse("B*40:06:21")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_22():
    result = parse("B*40:06:22")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_23():
    result = parse("B*40:06:23")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_24():
    result = parse("B*40:06:24")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_06_25():
    result = parse("B*40:06:25")
    assert result.__class__ is Allele, f'Expected parse("B*40:06:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:06:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_07():
    result = parse("B*40:07")
    assert result.__class__ is Allele, f'Expected parse("B*40:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_08():
    result = parse("B*40:08")
    assert result.__class__ is Allele, f'Expected parse("B*40:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_09():
    result = parse("B*40:09")
    assert result.__class__ is Allele, f'Expected parse("B*40:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_100():
    result = parse("B*40:100")
    assert result.__class__ is Allele, f'Expected parse("B*40:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_101():
    result = parse("B*40:101")
    assert result.__class__ is Allele, f'Expected parse("B*40:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_102():
    result = parse("B*40:102")
    assert result.__class__ is Allele, f'Expected parse("B*40:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_103():
    result = parse("B*40:103")
    assert result.__class__ is Allele, f'Expected parse("B*40:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_104():
    result = parse("B*40:104")
    assert result.__class__ is Allele, f'Expected parse("B*40:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_105():
    result = parse("B*40:105")
    assert result.__class__ is Allele, f'Expected parse("B*40:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_106():
    result = parse("B*40:106")
    assert result.__class__ is Allele, f'Expected parse("B*40:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_107():
    result = parse("B*40:107")
    assert result.__class__ is Allele, f'Expected parse("B*40:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_108():
    result = parse("B*40:108")
    assert result.__class__ is Allele, f'Expected parse("B*40:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_109():
    result = parse("B*40:109")
    assert result.__class__ is Allele, f'Expected parse("B*40:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_10_01_01():
    result = parse("B*40:10:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:10:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:10:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_10_01_02():
    result = parse("B*40:10:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:10:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:10:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_10_02():
    result = parse("B*40:10:02")
    assert result.__class__ is Allele, f'Expected parse("B*40:10:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:10:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_110():
    result = parse("B*40:110")
    assert result.__class__ is Allele, f'Expected parse("B*40:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_111():
    result = parse("B*40:111")
    assert result.__class__ is Allele, f'Expected parse("B*40:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_112():
    result = parse("B*40:112")
    assert result.__class__ is Allele, f'Expected parse("B*40:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_113():
    result = parse("B*40:113")
    assert result.__class__ is Allele, f'Expected parse("B*40:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_114_01_01():
    result = parse("B*40:114:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:114:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:114:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_114_01_02():
    result = parse("B*40:114:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:114:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:114:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_114_02():
    result = parse("B*40:114:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:114:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:114:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_115():
    result = parse("B*40:115")
    assert result.__class__ is Allele, f'Expected parse("B*40:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_116():
    result = parse("B*40:116")
    assert result.__class__ is Allele, f'Expected parse("B*40:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_117():
    result = parse("B*40:117")
    assert result.__class__ is Allele, f'Expected parse("B*40:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_118N():
    result = parse("B*40:118N")
    assert result.__class__ is Allele, f'Expected parse("B*40:118N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:118N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_119():
    result = parse("B*40:119")
    assert result.__class__ is Allele, f'Expected parse("B*40:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_11_01_01():
    result = parse("B*40:11:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:11:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:11:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_11_01_02():
    result = parse("B*40:11:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:11:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:11:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_11_01_03():
    result = parse("B*40:11:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:11:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:11:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_11_02():
    result = parse("B*40:11:02")
    assert result.__class__ is Allele, f'Expected parse("B*40:11:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:11:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_120():
    result = parse("B*40:120")
    assert result.__class__ is Allele, f'Expected parse("B*40:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_121():
    result = parse("B*40:121")
    assert result.__class__ is Allele, f'Expected parse("B*40:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_122():
    result = parse("B*40:122")
    assert result.__class__ is Allele, f'Expected parse("B*40:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_123():
    result = parse("B*40:123")
    assert result.__class__ is Allele, f'Expected parse("B*40:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_124_01():
    result = parse("B*40:124:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:124:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:124:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_124_02():
    result = parse("B*40:124:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:124:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:124:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_125_01():
    result = parse("B*40:125:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:125:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:125:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_125_02():
    result = parse("B*40:125:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:125:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:125:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_125_03():
    result = parse("B*40:125:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:125:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:125:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_126():
    result = parse("B*40:126")
    assert result.__class__ is Allele, f'Expected parse("B*40:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_127():
    result = parse("B*40:127")
    assert result.__class__ is Allele, f'Expected parse("B*40:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_128():
    result = parse("B*40:128")
    assert result.__class__ is Allele, f'Expected parse("B*40:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_129():
    result = parse("B*40:129")
    assert result.__class__ is Allele, f'Expected parse("B*40:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_12_01():
    result = parse("B*40:12:01")
    assert result.__class__ is Allele, f'Expected parse("B*40:12:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:12:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_12_02():
    result = parse("B*40:12:02")
    assert result.__class__ is Allele, f'Expected parse("B*40:12:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:12:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_13():
    result = parse("B*40:13")
    assert result.__class__ is Allele, f'Expected parse("B*40:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_130_01():
    result = parse("B*40:130:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:130:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:130:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_130_02():
    result = parse("B*40:130:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:130:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:130:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_131():
    result = parse("B*40:131")
    assert result.__class__ is Allele, f'Expected parse("B*40:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_132():
    result = parse("B*40:132")
    assert result.__class__ is Allele, f'Expected parse("B*40:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_133Q():
    result = parse("B*40:133Q")
    assert result.__class__ is Allele, f'Expected parse("B*40:133Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:133Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_134():
    result = parse("B*40:134")
    assert result.__class__ is Allele, f'Expected parse("B*40:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_135():
    result = parse("B*40:135")
    assert result.__class__ is Allele, f'Expected parse("B*40:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_136():
    result = parse("B*40:136")
    assert result.__class__ is Allele, f'Expected parse("B*40:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_137():
    result = parse("B*40:137")
    assert result.__class__ is Allele, f'Expected parse("B*40:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_138():
    result = parse("B*40:138")
    assert result.__class__ is Allele, f'Expected parse("B*40:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_139():
    result = parse("B*40:139")
    assert result.__class__ is Allele, f'Expected parse("B*40:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_140():
    result = parse("B*40:140")
    assert result.__class__ is Allele, f'Expected parse("B*40:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_141():
    result = parse("B*40:141")
    assert result.__class__ is Allele, f'Expected parse("B*40:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_142N():
    result = parse("B*40:142N")
    assert result.__class__ is Allele, f'Expected parse("B*40:142N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:142N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_143():
    result = parse("B*40:143")
    assert result.__class__ is Allele, f'Expected parse("B*40:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_144N():
    result = parse("B*40:144N")
    assert result.__class__ is Allele, f'Expected parse("B*40:144N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:144N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_145():
    result = parse("B*40:145")
    assert result.__class__ is Allele, f'Expected parse("B*40:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_146():
    result = parse("B*40:146")
    assert result.__class__ is Allele, f'Expected parse("B*40:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_147():
    result = parse("B*40:147")
    assert result.__class__ is Allele, f'Expected parse("B*40:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_148():
    result = parse("B*40:148")
    assert result.__class__ is Allele, f'Expected parse("B*40:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_149():
    result = parse("B*40:149")
    assert result.__class__ is Allele, f'Expected parse("B*40:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_14_01():
    result = parse("B*40:14:01")
    assert result.__class__ is Allele, f'Expected parse("B*40:14:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:14:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_14_02():
    result = parse("B*40:14:02")
    assert result.__class__ is Allele, f'Expected parse("B*40:14:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:14:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_14_03():
    result = parse("B*40:14:03")
    assert result.__class__ is Allele, f'Expected parse("B*40:14:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:14:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_15():
    result = parse("B*40:15")
    assert result.__class__ is Allele, f'Expected parse("B*40:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_150():
    result = parse("B*40:150")
    assert result.__class__ is Allele, f'Expected parse("B*40:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_151():
    result = parse("B*40:151")
    assert result.__class__ is Allele, f'Expected parse("B*40:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_152():
    result = parse("B*40:152")
    assert result.__class__ is Allele, f'Expected parse("B*40:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_153():
    result = parse("B*40:153")
    assert result.__class__ is Allele, f'Expected parse("B*40:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_154():
    result = parse("B*40:154")
    assert result.__class__ is Allele, f'Expected parse("B*40:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_155_01N():
    result = parse("B*40:155:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:155:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:155:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_155_02N():
    result = parse("B*40:155:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:155:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:155:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_156():
    result = parse("B*40:156")
    assert result.__class__ is Allele, f'Expected parse("B*40:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_157():
    result = parse("B*40:157")
    assert result.__class__ is Allele, f'Expected parse("B*40:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_158():
    result = parse("B*40:158")
    assert result.__class__ is Allele, f'Expected parse("B*40:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_159():
    result = parse("B*40:159")
    assert result.__class__ is Allele, f'Expected parse("B*40:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_160_01():
    result = parse("B*40:160:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:160:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:160:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_160_02():
    result = parse("B*40:160:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:160:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:160:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_161():
    result = parse("B*40:161")
    assert result.__class__ is Allele, f'Expected parse("B*40:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_162():
    result = parse("B*40:162")
    assert result.__class__ is Allele, f'Expected parse("B*40:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_163():
    result = parse("B*40:163")
    assert result.__class__ is Allele, f'Expected parse("B*40:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_164():
    result = parse("B*40:164")
    assert result.__class__ is Allele, f'Expected parse("B*40:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_165():
    result = parse("B*40:165")
    assert result.__class__ is Allele, f'Expected parse("B*40:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_166():
    result = parse("B*40:166")
    assert result.__class__ is Allele, f'Expected parse("B*40:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_167():
    result = parse("B*40:167")
    assert result.__class__ is Allele, f'Expected parse("B*40:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_168():
    result = parse("B*40:168")
    assert result.__class__ is Allele, f'Expected parse("B*40:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_169():
    result = parse("B*40:169")
    assert result.__class__ is Allele, f'Expected parse("B*40:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_16_01_01():
    result = parse("B*40:16:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:16:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:16:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_16_01_02():
    result = parse("B*40:16:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:16:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:16:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_170():
    result = parse("B*40:170")
    assert result.__class__ is Allele, f'Expected parse("B*40:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_171():
    result = parse("B*40:171")
    assert result.__class__ is Allele, f'Expected parse("B*40:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_172():
    result = parse("B*40:172")
    assert result.__class__ is Allele, f'Expected parse("B*40:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_173():
    result = parse("B*40:173")
    assert result.__class__ is Allele, f'Expected parse("B*40:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_174():
    result = parse("B*40:174")
    assert result.__class__ is Allele, f'Expected parse("B*40:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_175():
    result = parse("B*40:175")
    assert result.__class__ is Allele, f'Expected parse("B*40:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_176():
    result = parse("B*40:176")
    assert result.__class__ is Allele, f'Expected parse("B*40:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_177():
    result = parse("B*40:177")
    assert result.__class__ is Allele, f'Expected parse("B*40:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_178():
    result = parse("B*40:178")
    assert result.__class__ is Allele, f'Expected parse("B*40:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_179():
    result = parse("B*40:179")
    assert result.__class__ is Allele, f'Expected parse("B*40:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_18():
    result = parse("B*40:18")
    assert result.__class__ is Allele, f'Expected parse("B*40:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_180():
    result = parse("B*40:180")
    assert result.__class__ is Allele, f'Expected parse("B*40:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_181():
    result = parse("B*40:181")
    assert result.__class__ is Allele, f'Expected parse("B*40:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_182():
    result = parse("B*40:182")
    assert result.__class__ is Allele, f'Expected parse("B*40:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_183():
    result = parse("B*40:183")
    assert result.__class__ is Allele, f'Expected parse("B*40:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_184():
    result = parse("B*40:184")
    assert result.__class__ is Allele, f'Expected parse("B*40:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_185():
    result = parse("B*40:185")
    assert result.__class__ is Allele, f'Expected parse("B*40:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_186_01():
    result = parse("B*40:186:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:186:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:186:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_186_02():
    result = parse("B*40:186:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:186:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:186:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_187():
    result = parse("B*40:187")
    assert result.__class__ is Allele, f'Expected parse("B*40:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_188():
    result = parse("B*40:188")
    assert result.__class__ is Allele, f'Expected parse("B*40:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_189():
    result = parse("B*40:189")
    assert result.__class__ is Allele, f'Expected parse("B*40:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_19():
    result = parse("B*40:19")
    assert result.__class__ is Allele, f'Expected parse("B*40:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_190():
    result = parse("B*40:190")
    assert result.__class__ is Allele, f'Expected parse("B*40:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_191():
    result = parse("B*40:191")
    assert result.__class__ is Allele, f'Expected parse("B*40:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_192():
    result = parse("B*40:192")
    assert result.__class__ is Allele, f'Expected parse("B*40:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_193():
    result = parse("B*40:193")
    assert result.__class__ is Allele, f'Expected parse("B*40:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_194():
    result = parse("B*40:194")
    assert result.__class__ is Allele, f'Expected parse("B*40:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_195():
    result = parse("B*40:195")
    assert result.__class__ is Allele, f'Expected parse("B*40:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_196():
    result = parse("B*40:196")
    assert result.__class__ is Allele, f'Expected parse("B*40:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_197():
    result = parse("B*40:197")
    assert result.__class__ is Allele, f'Expected parse("B*40:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_198():
    result = parse("B*40:198")
    assert result.__class__ is Allele, f'Expected parse("B*40:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_199():
    result = parse("B*40:199")
    assert result.__class__ is Allele, f'Expected parse("B*40:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_200():
    result = parse("B*40:200")
    assert result.__class__ is Allele, f'Expected parse("B*40:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_201():
    result = parse("B*40:201")
    assert result.__class__ is Allele, f'Expected parse("B*40:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_202():
    result = parse("B*40:202")
    assert result.__class__ is Allele, f'Expected parse("B*40:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_203():
    result = parse("B*40:203")
    assert result.__class__ is Allele, f'Expected parse("B*40:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_204():
    result = parse("B*40:204")
    assert result.__class__ is Allele, f'Expected parse("B*40:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_205():
    result = parse("B*40:205")
    assert result.__class__ is Allele, f'Expected parse("B*40:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_206():
    result = parse("B*40:206")
    assert result.__class__ is Allele, f'Expected parse("B*40:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_207():
    result = parse("B*40:207")
    assert result.__class__ is Allele, f'Expected parse("B*40:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_208():
    result = parse("B*40:208")
    assert result.__class__ is Allele, f'Expected parse("B*40:208") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_209():
    result = parse("B*40:209")
    assert result.__class__ is Allele, f'Expected parse("B*40:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_20_01_01():
    result = parse("B*40:20:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:20:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:20:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_20_01_02():
    result = parse("B*40:20:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:20:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:20:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_21():
    result = parse("B*40:21")
    assert result.__class__ is Allele, f'Expected parse("B*40:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_210():
    result = parse("B*40:210")
    assert result.__class__ is Allele, f'Expected parse("B*40:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_211():
    result = parse("B*40:211")
    assert result.__class__ is Allele, f'Expected parse("B*40:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_212():
    result = parse("B*40:212")
    assert result.__class__ is Allele, f'Expected parse("B*40:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_213():
    result = parse("B*40:213")
    assert result.__class__ is Allele, f'Expected parse("B*40:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_214():
    result = parse("B*40:214")
    assert result.__class__ is Allele, f'Expected parse("B*40:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_215():
    result = parse("B*40:215")
    assert result.__class__ is Allele, f'Expected parse("B*40:215") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_216N():
    result = parse("B*40:216N")
    assert result.__class__ is Allele, f'Expected parse("B*40:216N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:216N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_217():
    result = parse("B*40:217")
    assert result.__class__ is Allele, f'Expected parse("B*40:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_218():
    result = parse("B*40:218")
    assert result.__class__ is Allele, f'Expected parse("B*40:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_219():
    result = parse("B*40:219")
    assert result.__class__ is Allele, f'Expected parse("B*40:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_220():
    result = parse("B*40:220")
    assert result.__class__ is Allele, f'Expected parse("B*40:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_221():
    result = parse("B*40:221")
    assert result.__class__ is Allele, f'Expected parse("B*40:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_222():
    result = parse("B*40:222")
    assert result.__class__ is Allele, f'Expected parse("B*40:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_223():
    result = parse("B*40:223")
    assert result.__class__ is Allele, f'Expected parse("B*40:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_224():
    result = parse("B*40:224")
    assert result.__class__ is Allele, f'Expected parse("B*40:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_225_01():
    result = parse("B*40:225:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:225:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:225:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_225_02():
    result = parse("B*40:225:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:225:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:225:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_226():
    result = parse("B*40:226")
    assert result.__class__ is Allele, f'Expected parse("B*40:226") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_227():
    result = parse("B*40:227")
    assert result.__class__ is Allele, f'Expected parse("B*40:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_228():
    result = parse("B*40:228")
    assert result.__class__ is Allele, f'Expected parse("B*40:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_229():
    result = parse("B*40:229")
    assert result.__class__ is Allele, f'Expected parse("B*40:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_22N():
    result = parse("B*40:22N")
    assert result.__class__ is Allele, f'Expected parse("B*40:22N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:22N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_23():
    result = parse("B*40:23")
    assert result.__class__ is Allele, f'Expected parse("B*40:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_230():
    result = parse("B*40:230")
    assert result.__class__ is Allele, f'Expected parse("B*40:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_231():
    result = parse("B*40:231")
    assert result.__class__ is Allele, f'Expected parse("B*40:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_232():
    result = parse("B*40:232")
    assert result.__class__ is Allele, f'Expected parse("B*40:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_233():
    result = parse("B*40:233")
    assert result.__class__ is Allele, f'Expected parse("B*40:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_234():
    result = parse("B*40:234")
    assert result.__class__ is Allele, f'Expected parse("B*40:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_235():
    result = parse("B*40:235")
    assert result.__class__ is Allele, f'Expected parse("B*40:235") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_236():
    result = parse("B*40:236")
    assert result.__class__ is Allele, f'Expected parse("B*40:236") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_237():
    result = parse("B*40:237")
    assert result.__class__ is Allele, f'Expected parse("B*40:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_238():
    result = parse("B*40:238")
    assert result.__class__ is Allele, f'Expected parse("B*40:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_239():
    result = parse("B*40:239")
    assert result.__class__ is Allele, f'Expected parse("B*40:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_24():
    result = parse("B*40:24")
    assert result.__class__ is Allele, f'Expected parse("B*40:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_240():
    result = parse("B*40:240")
    assert result.__class__ is Allele, f'Expected parse("B*40:240") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_241():
    result = parse("B*40:241")
    assert result.__class__ is Allele, f'Expected parse("B*40:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_242():
    result = parse("B*40:242")
    assert result.__class__ is Allele, f'Expected parse("B*40:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_243():
    result = parse("B*40:243")
    assert result.__class__ is Allele, f'Expected parse("B*40:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_244():
    result = parse("B*40:244")
    assert result.__class__ is Allele, f'Expected parse("B*40:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_245():
    result = parse("B*40:245")
    assert result.__class__ is Allele, f'Expected parse("B*40:245") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_246():
    result = parse("B*40:246")
    assert result.__class__ is Allele, f'Expected parse("B*40:246") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_247():
    result = parse("B*40:247")
    assert result.__class__ is Allele, f'Expected parse("B*40:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_248():
    result = parse("B*40:248")
    assert result.__class__ is Allele, f'Expected parse("B*40:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_249():
    result = parse("B*40:249")
    assert result.__class__ is Allele, f'Expected parse("B*40:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_25():
    result = parse("B*40:25")
    assert result.__class__ is Allele, f'Expected parse("B*40:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_250():
    result = parse("B*40:250")
    assert result.__class__ is Allele, f'Expected parse("B*40:250") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_251():
    result = parse("B*40:251")
    assert result.__class__ is Allele, f'Expected parse("B*40:251") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_252():
    result = parse("B*40:252")
    assert result.__class__ is Allele, f'Expected parse("B*40:252") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_253():
    result = parse("B*40:253")
    assert result.__class__ is Allele, f'Expected parse("B*40:253") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_254():
    result = parse("B*40:254")
    assert result.__class__ is Allele, f'Expected parse("B*40:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_255():
    result = parse("B*40:255")
    assert result.__class__ is Allele, f'Expected parse("B*40:255") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_256N():
    result = parse("B*40:256N")
    assert result.__class__ is Allele, f'Expected parse("B*40:256N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:256N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_257():
    result = parse("B*40:257")
    assert result.__class__ is Allele, f'Expected parse("B*40:257") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_258():
    result = parse("B*40:258")
    assert result.__class__ is Allele, f'Expected parse("B*40:258") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_259():
    result = parse("B*40:259")
    assert result.__class__ is Allele, f'Expected parse("B*40:259") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_26():
    result = parse("B*40:26")
    assert result.__class__ is Allele, f'Expected parse("B*40:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_260():
    result = parse("B*40:260")
    assert result.__class__ is Allele, f'Expected parse("B*40:260") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_261():
    result = parse("B*40:261")
    assert result.__class__ is Allele, f'Expected parse("B*40:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_262():
    result = parse("B*40:262")
    assert result.__class__ is Allele, f'Expected parse("B*40:262") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_263N():
    result = parse("B*40:263N")
    assert result.__class__ is Allele, f'Expected parse("B*40:263N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:263N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_264():
    result = parse("B*40:264")
    assert result.__class__ is Allele, f'Expected parse("B*40:264") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_265N():
    result = parse("B*40:265N")
    assert result.__class__ is Allele, f'Expected parse("B*40:265N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:265N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_266():
    result = parse("B*40:266")
    assert result.__class__ is Allele, f'Expected parse("B*40:266") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_267():
    result = parse("B*40:267")
    assert result.__class__ is Allele, f'Expected parse("B*40:267") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_268():
    result = parse("B*40:268")
    assert result.__class__ is Allele, f'Expected parse("B*40:268") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_269():
    result = parse("B*40:269")
    assert result.__class__ is Allele, f'Expected parse("B*40:269") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_270():
    result = parse("B*40:270")
    assert result.__class__ is Allele, f'Expected parse("B*40:270") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_271():
    result = parse("B*40:271")
    assert result.__class__ is Allele, f'Expected parse("B*40:271") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_272():
    result = parse("B*40:272")
    assert result.__class__ is Allele, f'Expected parse("B*40:272") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_273():
    result = parse("B*40:273")
    assert result.__class__ is Allele, f'Expected parse("B*40:273") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_274():
    result = parse("B*40:274")
    assert result.__class__ is Allele, f'Expected parse("B*40:274") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_275():
    result = parse("B*40:275")
    assert result.__class__ is Allele, f'Expected parse("B*40:275") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_276():
    result = parse("B*40:276")
    assert result.__class__ is Allele, f'Expected parse("B*40:276") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_277():
    result = parse("B*40:277")
    assert result.__class__ is Allele, f'Expected parse("B*40:277") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_278():
    result = parse("B*40:278")
    assert result.__class__ is Allele, f'Expected parse("B*40:278") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_279():
    result = parse("B*40:279")
    assert result.__class__ is Allele, f'Expected parse("B*40:279") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_27_01():
    result = parse("B*40:27:01")
    assert result.__class__ is Allele, f'Expected parse("B*40:27:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:27:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_27_02():
    result = parse("B*40:27:02")
    assert result.__class__ is Allele, f'Expected parse("B*40:27:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:27:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_27_03():
    result = parse("B*40:27:03")
    assert result.__class__ is Allele, f'Expected parse("B*40:27:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:27:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_28():
    result = parse("B*40:28")
    assert result.__class__ is Allele, f'Expected parse("B*40:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_280():
    result = parse("B*40:280")
    assert result.__class__ is Allele, f'Expected parse("B*40:280") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_281():
    result = parse("B*40:281")
    assert result.__class__ is Allele, f'Expected parse("B*40:281") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_282():
    result = parse("B*40:282")
    assert result.__class__ is Allele, f'Expected parse("B*40:282") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_283():
    result = parse("B*40:283")
    assert result.__class__ is Allele, f'Expected parse("B*40:283") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_284():
    result = parse("B*40:284")
    assert result.__class__ is Allele, f'Expected parse("B*40:284") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_285():
    result = parse("B*40:285")
    assert result.__class__ is Allele, f'Expected parse("B*40:285") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_286N():
    result = parse("B*40:286N")
    assert result.__class__ is Allele, f'Expected parse("B*40:286N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:286N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_287():
    result = parse("B*40:287")
    assert result.__class__ is Allele, f'Expected parse("B*40:287") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:287") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_288():
    result = parse("B*40:288")
    assert result.__class__ is Allele, f'Expected parse("B*40:288") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_289():
    result = parse("B*40:289")
    assert result.__class__ is Allele, f'Expected parse("B*40:289") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_29():
    result = parse("B*40:29")
    assert result.__class__ is Allele, f'Expected parse("B*40:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_290():
    result = parse("B*40:290")
    assert result.__class__ is Allele, f'Expected parse("B*40:290") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_291N():
    result = parse("B*40:291N")
    assert result.__class__ is Allele, f'Expected parse("B*40:291N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:291N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_292():
    result = parse("B*40:292")
    assert result.__class__ is Allele, f'Expected parse("B*40:292") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_293():
    result = parse("B*40:293")
    assert result.__class__ is Allele, f'Expected parse("B*40:293") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_294():
    result = parse("B*40:294")
    assert result.__class__ is Allele, f'Expected parse("B*40:294") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_295():
    result = parse("B*40:295")
    assert result.__class__ is Allele, f'Expected parse("B*40:295") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_296():
    result = parse("B*40:296")
    assert result.__class__ is Allele, f'Expected parse("B*40:296") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_297():
    result = parse("B*40:297")
    assert result.__class__ is Allele, f'Expected parse("B*40:297") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_298_01():
    result = parse("B*40:298:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:298:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:298:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_298_02():
    result = parse("B*40:298:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:298:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:298:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_299():
    result = parse("B*40:299")
    assert result.__class__ is Allele, f'Expected parse("B*40:299") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_30():
    result = parse("B*40:30")
    assert result.__class__ is Allele, f'Expected parse("B*40:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_300():
    result = parse("B*40:300")
    assert result.__class__ is Allele, f'Expected parse("B*40:300") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_301():
    result = parse("B*40:301")
    assert result.__class__ is Allele, f'Expected parse("B*40:301") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_302():
    result = parse("B*40:302")
    assert result.__class__ is Allele, f'Expected parse("B*40:302") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_303():
    result = parse("B*40:303")
    assert result.__class__ is Allele, f'Expected parse("B*40:303") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:303") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_304():
    result = parse("B*40:304")
    assert result.__class__ is Allele, f'Expected parse("B*40:304") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:304") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_305():
    result = parse("B*40:305")
    assert result.__class__ is Allele, f'Expected parse("B*40:305") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_306():
    result = parse("B*40:306")
    assert result.__class__ is Allele, f'Expected parse("B*40:306") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:306") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_307():
    result = parse("B*40:307")
    assert result.__class__ is Allele, f'Expected parse("B*40:307") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_308():
    result = parse("B*40:308")
    assert result.__class__ is Allele, f'Expected parse("B*40:308") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:308") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_309():
    result = parse("B*40:309")
    assert result.__class__ is Allele, f'Expected parse("B*40:309") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:309") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_31():
    result = parse("B*40:31")
    assert result.__class__ is Allele, f'Expected parse("B*40:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_310():
    result = parse("B*40:310")
    assert result.__class__ is Allele, f'Expected parse("B*40:310") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:310") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_311():
    result = parse("B*40:311")
    assert result.__class__ is Allele, f'Expected parse("B*40:311") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:311") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_312():
    result = parse("B*40:312")
    assert result.__class__ is Allele, f'Expected parse("B*40:312") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:312") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_313():
    result = parse("B*40:313")
    assert result.__class__ is Allele, f'Expected parse("B*40:313") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:313") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_314():
    result = parse("B*40:314")
    assert result.__class__ is Allele, f'Expected parse("B*40:314") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:314") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_315():
    result = parse("B*40:315")
    assert result.__class__ is Allele, f'Expected parse("B*40:315") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:315") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_316():
    result = parse("B*40:316")
    assert result.__class__ is Allele, f'Expected parse("B*40:316") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:316") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_317():
    result = parse("B*40:317")
    assert result.__class__ is Allele, f'Expected parse("B*40:317") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:317") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_318():
    result = parse("B*40:318")
    assert result.__class__ is Allele, f'Expected parse("B*40:318") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:318") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_319():
    result = parse("B*40:319")
    assert result.__class__ is Allele, f'Expected parse("B*40:319") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_32():
    result = parse("B*40:32")
    assert result.__class__ is Allele, f'Expected parse("B*40:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_320():
    result = parse("B*40:320")
    assert result.__class__ is Allele, f'Expected parse("B*40:320") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:320") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_321():
    result = parse("B*40:321")
    assert result.__class__ is Allele, f'Expected parse("B*40:321") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:321") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_322():
    result = parse("B*40:322")
    assert result.__class__ is Allele, f'Expected parse("B*40:322") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:322") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_323_01():
    result = parse("B*40:323:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:323:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:323:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_323_02():
    result = parse("B*40:323:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:323:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:323:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_324():
    result = parse("B*40:324")
    assert result.__class__ is Allele, f'Expected parse("B*40:324") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:324") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_325():
    result = parse("B*40:325")
    assert result.__class__ is Allele, f'Expected parse("B*40:325") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:325") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_326():
    result = parse("B*40:326")
    assert result.__class__ is Allele, f'Expected parse("B*40:326") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:326") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_327():
    result = parse("B*40:327")
    assert result.__class__ is Allele, f'Expected parse("B*40:327") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:327") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_328():
    result = parse("B*40:328")
    assert result.__class__ is Allele, f'Expected parse("B*40:328") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:328") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_329():
    result = parse("B*40:329")
    assert result.__class__ is Allele, f'Expected parse("B*40:329") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:329") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_33():
    result = parse("B*40:33")
    assert result.__class__ is Allele, f'Expected parse("B*40:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_330():
    result = parse("B*40:330")
    assert result.__class__ is Allele, f'Expected parse("B*40:330") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:330") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_331():
    result = parse("B*40:331")
    assert result.__class__ is Allele, f'Expected parse("B*40:331") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:331") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_332():
    result = parse("B*40:332")
    assert result.__class__ is Allele, f'Expected parse("B*40:332") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:332") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_333():
    result = parse("B*40:333")
    assert result.__class__ is Allele, f'Expected parse("B*40:333") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:333") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_334():
    result = parse("B*40:334")
    assert result.__class__ is Allele, f'Expected parse("B*40:334") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:334") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_335():
    result = parse("B*40:335")
    assert result.__class__ is Allele, f'Expected parse("B*40:335") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:335") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_336():
    result = parse("B*40:336")
    assert result.__class__ is Allele, f'Expected parse("B*40:336") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:336") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_337N():
    result = parse("B*40:337N")
    assert result.__class__ is Allele, f'Expected parse("B*40:337N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:337N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_338N():
    result = parse("B*40:338N")
    assert result.__class__ is Allele, f'Expected parse("B*40:338N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:338N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_339():
    result = parse("B*40:339")
    assert result.__class__ is Allele, f'Expected parse("B*40:339") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:339") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_34():
    result = parse("B*40:34")
    assert result.__class__ is Allele, f'Expected parse("B*40:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_340():
    result = parse("B*40:340")
    assert result.__class__ is Allele, f'Expected parse("B*40:340") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:340") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_341():
    result = parse("B*40:341")
    assert result.__class__ is Allele, f'Expected parse("B*40:341") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:341") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_342():
    result = parse("B*40:342")
    assert result.__class__ is Allele, f'Expected parse("B*40:342") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:342") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_343():
    result = parse("B*40:343")
    assert result.__class__ is Allele, f'Expected parse("B*40:343") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:343") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_344():
    result = parse("B*40:344")
    assert result.__class__ is Allele, f'Expected parse("B*40:344") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:344") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_345N():
    result = parse("B*40:345N")
    assert result.__class__ is Allele, f'Expected parse("B*40:345N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:345N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_346():
    result = parse("B*40:346")
    assert result.__class__ is Allele, f'Expected parse("B*40:346") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:346") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_347():
    result = parse("B*40:347")
    assert result.__class__ is Allele, f'Expected parse("B*40:347") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:347") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_348():
    result = parse("B*40:348")
    assert result.__class__ is Allele, f'Expected parse("B*40:348") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:348") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_349():
    result = parse("B*40:349")
    assert result.__class__ is Allele, f'Expected parse("B*40:349") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:349") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_350():
    result = parse("B*40:350")
    assert result.__class__ is Allele, f'Expected parse("B*40:350") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:350") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_351():
    result = parse("B*40:351")
    assert result.__class__ is Allele, f'Expected parse("B*40:351") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:351") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_352():
    result = parse("B*40:352")
    assert result.__class__ is Allele, f'Expected parse("B*40:352") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:352") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_353_01():
    result = parse("B*40:353:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:353:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:353:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_353_02():
    result = parse("B*40:353:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:353:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:353:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_354():
    result = parse("B*40:354")
    assert result.__class__ is Allele, f'Expected parse("B*40:354") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:354") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_355():
    result = parse("B*40:355")
    assert result.__class__ is Allele, f'Expected parse("B*40:355") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:355") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_356():
    result = parse("B*40:356")
    assert result.__class__ is Allele, f'Expected parse("B*40:356") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:356") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_357():
    result = parse("B*40:357")
    assert result.__class__ is Allele, f'Expected parse("B*40:357") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:357") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_358():
    result = parse("B*40:358")
    assert result.__class__ is Allele, f'Expected parse("B*40:358") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:358") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_359():
    result = parse("B*40:359")
    assert result.__class__ is Allele, f'Expected parse("B*40:359") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:359") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_35_01():
    result = parse("B*40:35:01")
    assert result.__class__ is Allele, f'Expected parse("B*40:35:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:35:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_35_02():
    result = parse("B*40:35:02")
    assert result.__class__ is Allele, f'Expected parse("B*40:35:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:35:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_36():
    result = parse("B*40:36")
    assert result.__class__ is Allele, f'Expected parse("B*40:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_360():
    result = parse("B*40:360")
    assert result.__class__ is Allele, f'Expected parse("B*40:360") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:360") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_361N():
    result = parse("B*40:361N")
    assert result.__class__ is Allele, f'Expected parse("B*40:361N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:361N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_362():
    result = parse("B*40:362")
    assert result.__class__ is Allele, f'Expected parse("B*40:362") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:362") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_363():
    result = parse("B*40:363")
    assert result.__class__ is Allele, f'Expected parse("B*40:363") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:363") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_364():
    result = parse("B*40:364")
    assert result.__class__ is Allele, f'Expected parse("B*40:364") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:364") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_365():
    result = parse("B*40:365")
    assert result.__class__ is Allele, f'Expected parse("B*40:365") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:365") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_366():
    result = parse("B*40:366")
    assert result.__class__ is Allele, f'Expected parse("B*40:366") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:366") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_367():
    result = parse("B*40:367")
    assert result.__class__ is Allele, f'Expected parse("B*40:367") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:367") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_368():
    result = parse("B*40:368")
    assert result.__class__ is Allele, f'Expected parse("B*40:368") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:368") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_369():
    result = parse("B*40:369")
    assert result.__class__ is Allele, f'Expected parse("B*40:369") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:369") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_37():
    result = parse("B*40:37")
    assert result.__class__ is Allele, f'Expected parse("B*40:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_370():
    result = parse("B*40:370")
    assert result.__class__ is Allele, f'Expected parse("B*40:370") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:370") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_371():
    result = parse("B*40:371")
    assert result.__class__ is Allele, f'Expected parse("B*40:371") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:371") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_372N():
    result = parse("B*40:372N")
    assert result.__class__ is Allele, f'Expected parse("B*40:372N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:372N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_373():
    result = parse("B*40:373")
    assert result.__class__ is Allele, f'Expected parse("B*40:373") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:373") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_374():
    result = parse("B*40:374")
    assert result.__class__ is Allele, f'Expected parse("B*40:374") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:374") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_375():
    result = parse("B*40:375")
    assert result.__class__ is Allele, f'Expected parse("B*40:375") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:375") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_376():
    result = parse("B*40:376")
    assert result.__class__ is Allele, f'Expected parse("B*40:376") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:376") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_377():
    result = parse("B*40:377")
    assert result.__class__ is Allele, f'Expected parse("B*40:377") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:377") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_378():
    result = parse("B*40:378")
    assert result.__class__ is Allele, f'Expected parse("B*40:378") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:378") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_379():
    result = parse("B*40:379")
    assert result.__class__ is Allele, f'Expected parse("B*40:379") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:379") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_38():
    result = parse("B*40:38")
    assert result.__class__ is Allele, f'Expected parse("B*40:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_380():
    result = parse("B*40:380")
    assert result.__class__ is Allele, f'Expected parse("B*40:380") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:380") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_381():
    result = parse("B*40:381")
    assert result.__class__ is Allele, f'Expected parse("B*40:381") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:381") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_382():
    result = parse("B*40:382")
    assert result.__class__ is Allele, f'Expected parse("B*40:382") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:382") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_383():
    result = parse("B*40:383")
    assert result.__class__ is Allele, f'Expected parse("B*40:383") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:383") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_384():
    result = parse("B*40:384")
    assert result.__class__ is Allele, f'Expected parse("B*40:384") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:384") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_385():
    result = parse("B*40:385")
    assert result.__class__ is Allele, f'Expected parse("B*40:385") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:385") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_386():
    result = parse("B*40:386")
    assert result.__class__ is Allele, f'Expected parse("B*40:386") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:386") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_387():
    result = parse("B*40:387")
    assert result.__class__ is Allele, f'Expected parse("B*40:387") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:387") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_388():
    result = parse("B*40:388")
    assert result.__class__ is Allele, f'Expected parse("B*40:388") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:388") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_389():
    result = parse("B*40:389")
    assert result.__class__ is Allele, f'Expected parse("B*40:389") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:389") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_39():
    result = parse("B*40:39")
    assert result.__class__ is Allele, f'Expected parse("B*40:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_390():
    result = parse("B*40:390")
    assert result.__class__ is Allele, f'Expected parse("B*40:390") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:390") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_391():
    result = parse("B*40:391")
    assert result.__class__ is Allele, f'Expected parse("B*40:391") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:391") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_392():
    result = parse("B*40:392")
    assert result.__class__ is Allele, f'Expected parse("B*40:392") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:392") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_393():
    result = parse("B*40:393")
    assert result.__class__ is Allele, f'Expected parse("B*40:393") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:393") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_394():
    result = parse("B*40:394")
    assert result.__class__ is Allele, f'Expected parse("B*40:394") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:394") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_395():
    result = parse("B*40:395")
    assert result.__class__ is Allele, f'Expected parse("B*40:395") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:395") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_396():
    result = parse("B*40:396")
    assert result.__class__ is Allele, f'Expected parse("B*40:396") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:396") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_397():
    result = parse("B*40:397")
    assert result.__class__ is Allele, f'Expected parse("B*40:397") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:397") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_398():
    result = parse("B*40:398")
    assert result.__class__ is Allele, f'Expected parse("B*40:398") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:398") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_399N():
    result = parse("B*40:399N")
    assert result.__class__ is Allele, f'Expected parse("B*40:399N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:399N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_40():
    result = parse("B*40:40")
    assert result.__class__ is Allele, f'Expected parse("B*40:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_400():
    result = parse("B*40:400")
    assert result.__class__ is Allele, f'Expected parse("B*40:400") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:400") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_401():
    result = parse("B*40:401")
    assert result.__class__ is Allele, f'Expected parse("B*40:401") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:401") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_402():
    result = parse("B*40:402")
    assert result.__class__ is Allele, f'Expected parse("B*40:402") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:402") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_403():
    result = parse("B*40:403")
    assert result.__class__ is Allele, f'Expected parse("B*40:403") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:403") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_404():
    result = parse("B*40:404")
    assert result.__class__ is Allele, f'Expected parse("B*40:404") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:404") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_405():
    result = parse("B*40:405")
    assert result.__class__ is Allele, f'Expected parse("B*40:405") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:405") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_406():
    result = parse("B*40:406")
    assert result.__class__ is Allele, f'Expected parse("B*40:406") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:406") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_407():
    result = parse("B*40:407")
    assert result.__class__ is Allele, f'Expected parse("B*40:407") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:407") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_408():
    result = parse("B*40:408")
    assert result.__class__ is Allele, f'Expected parse("B*40:408") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:408") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_409():
    result = parse("B*40:409")
    assert result.__class__ is Allele, f'Expected parse("B*40:409") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:409") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_410():
    result = parse("B*40:410")
    assert result.__class__ is Allele, f'Expected parse("B*40:410") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:410") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_411():
    result = parse("B*40:411")
    assert result.__class__ is Allele, f'Expected parse("B*40:411") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:411") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_412():
    result = parse("B*40:412")
    assert result.__class__ is Allele, f'Expected parse("B*40:412") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:412") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_413():
    result = parse("B*40:413")
    assert result.__class__ is Allele, f'Expected parse("B*40:413") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:413") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_414():
    result = parse("B*40:414")
    assert result.__class__ is Allele, f'Expected parse("B*40:414") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:414") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_415():
    result = parse("B*40:415")
    assert result.__class__ is Allele, f'Expected parse("B*40:415") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:415") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_416():
    result = parse("B*40:416")
    assert result.__class__ is Allele, f'Expected parse("B*40:416") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:416") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_417():
    result = parse("B*40:417")
    assert result.__class__ is Allele, f'Expected parse("B*40:417") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:417") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_418():
    result = parse("B*40:418")
    assert result.__class__ is Allele, f'Expected parse("B*40:418") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:418") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_419():
    result = parse("B*40:419")
    assert result.__class__ is Allele, f'Expected parse("B*40:419") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:419") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_42():
    result = parse("B*40:42")
    assert result.__class__ is Allele, f'Expected parse("B*40:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_420():
    result = parse("B*40:420")
    assert result.__class__ is Allele, f'Expected parse("B*40:420") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:420") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_421Q():
    result = parse("B*40:421Q")
    assert result.__class__ is Allele, f'Expected parse("B*40:421Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:421Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_422():
    result = parse("B*40:422")
    assert result.__class__ is Allele, f'Expected parse("B*40:422") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:422") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_423():
    result = parse("B*40:423")
    assert result.__class__ is Allele, f'Expected parse("B*40:423") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:423") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_424():
    result = parse("B*40:424")
    assert result.__class__ is Allele, f'Expected parse("B*40:424") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:424") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_425():
    result = parse("B*40:425")
    assert result.__class__ is Allele, f'Expected parse("B*40:425") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:425") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_426N():
    result = parse("B*40:426N")
    assert result.__class__ is Allele, f'Expected parse("B*40:426N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:426N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_427():
    result = parse("B*40:427")
    assert result.__class__ is Allele, f'Expected parse("B*40:427") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:427") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_428N():
    result = parse("B*40:428N")
    assert result.__class__ is Allele, f'Expected parse("B*40:428N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:428N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_429():
    result = parse("B*40:429")
    assert result.__class__ is Allele, f'Expected parse("B*40:429") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:429") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_43():
    result = parse("B*40:43")
    assert result.__class__ is Allele, f'Expected parse("B*40:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_430():
    result = parse("B*40:430")
    assert result.__class__ is Allele, f'Expected parse("B*40:430") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:430") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_431():
    result = parse("B*40:431")
    assert result.__class__ is Allele, f'Expected parse("B*40:431") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:431") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_432():
    result = parse("B*40:432")
    assert result.__class__ is Allele, f'Expected parse("B*40:432") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:432") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_433():
    result = parse("B*40:433")
    assert result.__class__ is Allele, f'Expected parse("B*40:433") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:433") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_434():
    result = parse("B*40:434")
    assert result.__class__ is Allele, f'Expected parse("B*40:434") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:434") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_435():
    result = parse("B*40:435")
    assert result.__class__ is Allele, f'Expected parse("B*40:435") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:435") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_436():
    result = parse("B*40:436")
    assert result.__class__ is Allele, f'Expected parse("B*40:436") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:436") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_437():
    result = parse("B*40:437")
    assert result.__class__ is Allele, f'Expected parse("B*40:437") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:437") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_438N():
    result = parse("B*40:438N")
    assert result.__class__ is Allele, f'Expected parse("B*40:438N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:438N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_439():
    result = parse("B*40:439")
    assert result.__class__ is Allele, f'Expected parse("B*40:439") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:439") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_44():
    result = parse("B*40:44")
    assert result.__class__ is Allele, f'Expected parse("B*40:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_440():
    result = parse("B*40:440")
    assert result.__class__ is Allele, f'Expected parse("B*40:440") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:440") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_441():
    result = parse("B*40:441")
    assert result.__class__ is Allele, f'Expected parse("B*40:441") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:441") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_442():
    result = parse("B*40:442")
    assert result.__class__ is Allele, f'Expected parse("B*40:442") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:442") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_443():
    result = parse("B*40:443")
    assert result.__class__ is Allele, f'Expected parse("B*40:443") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:443") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_444():
    result = parse("B*40:444")
    assert result.__class__ is Allele, f'Expected parse("B*40:444") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:444") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_445():
    result = parse("B*40:445")
    assert result.__class__ is Allele, f'Expected parse("B*40:445") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:445") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_446():
    result = parse("B*40:446")
    assert result.__class__ is Allele, f'Expected parse("B*40:446") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:446") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_447():
    result = parse("B*40:447")
    assert result.__class__ is Allele, f'Expected parse("B*40:447") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:447") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_448():
    result = parse("B*40:448")
    assert result.__class__ is Allele, f'Expected parse("B*40:448") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:448") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_449():
    result = parse("B*40:449")
    assert result.__class__ is Allele, f'Expected parse("B*40:449") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:449") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_45():
    result = parse("B*40:45")
    assert result.__class__ is Allele, f'Expected parse("B*40:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_450():
    result = parse("B*40:450")
    assert result.__class__ is Allele, f'Expected parse("B*40:450") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:450") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_451():
    result = parse("B*40:451")
    assert result.__class__ is Allele, f'Expected parse("B*40:451") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:451") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_452():
    result = parse("B*40:452")
    assert result.__class__ is Allele, f'Expected parse("B*40:452") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:452") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_453():
    result = parse("B*40:453")
    assert result.__class__ is Allele, f'Expected parse("B*40:453") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:453") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_454():
    result = parse("B*40:454")
    assert result.__class__ is Allele, f'Expected parse("B*40:454") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:454") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_455():
    result = parse("B*40:455")
    assert result.__class__ is Allele, f'Expected parse("B*40:455") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:455") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_456():
    result = parse("B*40:456")
    assert result.__class__ is Allele, f'Expected parse("B*40:456") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:456") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_457():
    result = parse("B*40:457")
    assert result.__class__ is Allele, f'Expected parse("B*40:457") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:457") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_458():
    result = parse("B*40:458")
    assert result.__class__ is Allele, f'Expected parse("B*40:458") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:458") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_459():
    result = parse("B*40:459")
    assert result.__class__ is Allele, f'Expected parse("B*40:459") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:459") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_46():
    result = parse("B*40:46")
    assert result.__class__ is Allele, f'Expected parse("B*40:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_460():
    result = parse("B*40:460")
    assert result.__class__ is Allele, f'Expected parse("B*40:460") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:460") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_461():
    result = parse("B*40:461")
    assert result.__class__ is Allele, f'Expected parse("B*40:461") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:461") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_462():
    result = parse("B*40:462")
    assert result.__class__ is Allele, f'Expected parse("B*40:462") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:462") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_47():
    result = parse("B*40:47")
    assert result.__class__ is Allele, f'Expected parse("B*40:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_48():
    result = parse("B*40:48")
    assert result.__class__ is Allele, f'Expected parse("B*40:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_49():
    result = parse("B*40:49")
    assert result.__class__ is Allele, f'Expected parse("B*40:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_50_01_01():
    result = parse("B*40:50:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:50:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:50:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_50_01_02():
    result = parse("B*40:50:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:50:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:50:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_51():
    result = parse("B*40:51")
    assert result.__class__ is Allele, f'Expected parse("B*40:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_52():
    result = parse("B*40:52")
    assert result.__class__ is Allele, f'Expected parse("B*40:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_53():
    result = parse("B*40:53")
    assert result.__class__ is Allele, f'Expected parse("B*40:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_54():
    result = parse("B*40:54")
    assert result.__class__ is Allele, f'Expected parse("B*40:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_55():
    result = parse("B*40:55")
    assert result.__class__ is Allele, f'Expected parse("B*40:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_56():
    result = parse("B*40:56")
    assert result.__class__ is Allele, f'Expected parse("B*40:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_57():
    result = parse("B*40:57")
    assert result.__class__ is Allele, f'Expected parse("B*40:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_58():
    result = parse("B*40:58")
    assert result.__class__ is Allele, f'Expected parse("B*40:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_59():
    result = parse("B*40:59")
    assert result.__class__ is Allele, f'Expected parse("B*40:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_60():
    result = parse("B*40:60")
    assert result.__class__ is Allele, f'Expected parse("B*40:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_61():
    result = parse("B*40:61")
    assert result.__class__ is Allele, f'Expected parse("B*40:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_62():
    result = parse("B*40:62")
    assert result.__class__ is Allele, f'Expected parse("B*40:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_63():
    result = parse("B*40:63")
    assert result.__class__ is Allele, f'Expected parse("B*40:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_64_01_01():
    result = parse("B*40:64:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:64:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:64:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_64_01_02():
    result = parse("B*40:64:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*40:64:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*40:64:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_64_02():
    result = parse("B*40:64:02")
    assert result.__class__ is Allele, f'Expected parse("B*40:64:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:64:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_65():
    result = parse("B*40:65")
    assert result.__class__ is Allele, f'Expected parse("B*40:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_66():
    result = parse("B*40:66")
    assert result.__class__ is Allele, f'Expected parse("B*40:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_67():
    result = parse("B*40:67")
    assert result.__class__ is Allele, f'Expected parse("B*40:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_68():
    result = parse("B*40:68")
    assert result.__class__ is Allele, f'Expected parse("B*40:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_69():
    result = parse("B*40:69")
    assert result.__class__ is Allele, f'Expected parse("B*40:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_70_01():
    result = parse("B*40:70:01")
    assert result.__class__ is Allele, f'Expected parse("B*40:70:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:70:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_70_02():
    result = parse("B*40:70:02")
    assert result.__class__ is Allele, f'Expected parse("B*40:70:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:70:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_71():
    result = parse("B*40:71")
    assert result.__class__ is Allele, f'Expected parse("B*40:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_72_01():
    result = parse("B*40:72:01")
    assert result.__class__ is Allele, f'Expected parse("B*40:72:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:72:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_72_02():
    result = parse("B*40:72:02")
    assert result.__class__ is Allele, f'Expected parse("B*40:72:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:72:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_73():
    result = parse("B*40:73")
    assert result.__class__ is Allele, f'Expected parse("B*40:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_74():
    result = parse("B*40:74")
    assert result.__class__ is Allele, f'Expected parse("B*40:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_75():
    result = parse("B*40:75")
    assert result.__class__ is Allele, f'Expected parse("B*40:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_76():
    result = parse("B*40:76")
    assert result.__class__ is Allele, f'Expected parse("B*40:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_77():
    result = parse("B*40:77")
    assert result.__class__ is Allele, f'Expected parse("B*40:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_78():
    result = parse("B*40:78")
    assert result.__class__ is Allele, f'Expected parse("B*40:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_79():
    result = parse("B*40:79")
    assert result.__class__ is Allele, f'Expected parse("B*40:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_80():
    result = parse("B*40:80")
    assert result.__class__ is Allele, f'Expected parse("B*40:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_81():
    result = parse("B*40:81")
    assert result.__class__ is Allele, f'Expected parse("B*40:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_82():
    result = parse("B*40:82")
    assert result.__class__ is Allele, f'Expected parse("B*40:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_83():
    result = parse("B*40:83")
    assert result.__class__ is Allele, f'Expected parse("B*40:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_84():
    result = parse("B*40:84")
    assert result.__class__ is Allele, f'Expected parse("B*40:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_85():
    result = parse("B*40:85")
    assert result.__class__ is Allele, f'Expected parse("B*40:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_86():
    result = parse("B*40:86")
    assert result.__class__ is Allele, f'Expected parse("B*40:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_87_01():
    result = parse("B*40:87:01")
    assert result.__class__ is Allele, f'Expected parse("B*40:87:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:87:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_87_02():
    result = parse("B*40:87:02")
    assert result.__class__ is Allele, f'Expected parse("B*40:87:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*40:87:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_88():
    result = parse("B*40:88")
    assert result.__class__ is Allele, f'Expected parse("B*40:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_89():
    result = parse("B*40:89")
    assert result.__class__ is Allele, f'Expected parse("B*40:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_90():
    result = parse("B*40:90")
    assert result.__class__ is Allele, f'Expected parse("B*40:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_91():
    result = parse("B*40:91")
    assert result.__class__ is Allele, f'Expected parse("B*40:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_92():
    result = parse("B*40:92")
    assert result.__class__ is Allele, f'Expected parse("B*40:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_93():
    result = parse("B*40:93")
    assert result.__class__ is Allele, f'Expected parse("B*40:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_94():
    result = parse("B*40:94")
    assert result.__class__ is Allele, f'Expected parse("B*40:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_95():
    result = parse("B*40:95")
    assert result.__class__ is Allele, f'Expected parse("B*40:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_96():
    result = parse("B*40:96")
    assert result.__class__ is Allele, f'Expected parse("B*40:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_97():
    result = parse("B*40:97")
    assert result.__class__ is Allele, f'Expected parse("B*40:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_98():
    result = parse("B*40:98")
    assert result.__class__ is Allele, f'Expected parse("B*40:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_40_99():
    result = parse("B*40:99")
    assert result.__class__ is Allele, f'Expected parse("B*40:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*40:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_01_01_01():
    result = parse("B*41:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*41:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*41:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_01_01_02():
    result = parse("B*41:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*41:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*41:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_01_01_03():
    result = parse("B*41:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*41:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*41:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_01_01_04():
    result = parse("B*41:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*41:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*41:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_01_02():
    result = parse("B*41:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*41:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*41:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_01_03():
    result = parse("B*41:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*41:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*41:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_01_04():
    result = parse("B*41:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*41:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*41:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_01_05():
    result = parse("B*41:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*41:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*41:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_01_06():
    result = parse("B*41:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*41:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*41:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_01_07():
    result = parse("B*41:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*41:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*41:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_02_01_01():
    result = parse("B*41:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*41:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*41:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_02_01_02():
    result = parse("B*41:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*41:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*41:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_02_01_03():
    result = parse("B*41:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*41:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*41:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_02_01_04():
    result = parse("B*41:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*41:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*41:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_02_01_05():
    result = parse("B*41:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*41:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*41:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_02_01_06():
    result = parse("B*41:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*41:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*41:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_02_01_07():
    result = parse("B*41:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*41:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*41:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_02_01_08():
    result = parse("B*41:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*41:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*41:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_02_02():
    result = parse("B*41:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*41:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*41:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_02_03():
    result = parse("B*41:02:03")
    assert result.__class__ is Allele, f'Expected parse("B*41:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*41:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_02_04():
    result = parse("B*41:02:04")
    assert result.__class__ is Allele, f'Expected parse("B*41:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*41:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_02_05():
    result = parse("B*41:02:05")
    assert result.__class__ is Allele, f'Expected parse("B*41:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*41:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_02_06():
    result = parse("B*41:02:06")
    assert result.__class__ is Allele, f'Expected parse("B*41:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*41:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_02_07():
    result = parse("B*41:02:07")
    assert result.__class__ is Allele, f'Expected parse("B*41:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*41:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_02_08():
    result = parse("B*41:02:08")
    assert result.__class__ is Allele, f'Expected parse("B*41:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*41:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_02_09():
    result = parse("B*41:02:09")
    assert result.__class__ is Allele, f'Expected parse("B*41:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*41:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_03_01():
    result = parse("B*41:03:01")
    assert result.__class__ is Allele, f'Expected parse("B*41:03:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*41:03:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_03_02():
    result = parse("B*41:03:02")
    assert result.__class__ is Allele, f'Expected parse("B*41:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*41:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_04():
    result = parse("B*41:04")
    assert result.__class__ is Allele, f'Expected parse("B*41:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_05():
    result = parse("B*41:05")
    assert result.__class__ is Allele, f'Expected parse("B*41:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_06():
    result = parse("B*41:06")
    assert result.__class__ is Allele, f'Expected parse("B*41:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_07():
    result = parse("B*41:07")
    assert result.__class__ is Allele, f'Expected parse("B*41:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_08():
    result = parse("B*41:08")
    assert result.__class__ is Allele, f'Expected parse("B*41:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_09():
    result = parse("B*41:09")
    assert result.__class__ is Allele, f'Expected parse("B*41:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_10():
    result = parse("B*41:10")
    assert result.__class__ is Allele, f'Expected parse("B*41:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_11():
    result = parse("B*41:11")
    assert result.__class__ is Allele, f'Expected parse("B*41:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_12():
    result = parse("B*41:12")
    assert result.__class__ is Allele, f'Expected parse("B*41:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_13():
    result = parse("B*41:13")
    assert result.__class__ is Allele, f'Expected parse("B*41:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_14():
    result = parse("B*41:14")
    assert result.__class__ is Allele, f'Expected parse("B*41:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_15():
    result = parse("B*41:15")
    assert result.__class__ is Allele, f'Expected parse("B*41:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_16():
    result = parse("B*41:16")
    assert result.__class__ is Allele, f'Expected parse("B*41:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_17():
    result = parse("B*41:17")
    assert result.__class__ is Allele, f'Expected parse("B*41:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_18():
    result = parse("B*41:18")
    assert result.__class__ is Allele, f'Expected parse("B*41:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_19():
    result = parse("B*41:19")
    assert result.__class__ is Allele, f'Expected parse("B*41:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_20():
    result = parse("B*41:20")
    assert result.__class__ is Allele, f'Expected parse("B*41:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_21():
    result = parse("B*41:21")
    assert result.__class__ is Allele, f'Expected parse("B*41:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_22():
    result = parse("B*41:22")
    assert result.__class__ is Allele, f'Expected parse("B*41:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_23():
    result = parse("B*41:23")
    assert result.__class__ is Allele, f'Expected parse("B*41:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_24():
    result = parse("B*41:24")
    assert result.__class__ is Allele, f'Expected parse("B*41:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_25():
    result = parse("B*41:25")
    assert result.__class__ is Allele, f'Expected parse("B*41:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_26():
    result = parse("B*41:26")
    assert result.__class__ is Allele, f'Expected parse("B*41:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_27():
    result = parse("B*41:27")
    assert result.__class__ is Allele, f'Expected parse("B*41:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_28():
    result = parse("B*41:28")
    assert result.__class__ is Allele, f'Expected parse("B*41:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_29():
    result = parse("B*41:29")
    assert result.__class__ is Allele, f'Expected parse("B*41:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_30():
    result = parse("B*41:30")
    assert result.__class__ is Allele, f'Expected parse("B*41:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_31():
    result = parse("B*41:31")
    assert result.__class__ is Allele, f'Expected parse("B*41:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_32():
    result = parse("B*41:32")
    assert result.__class__ is Allele, f'Expected parse("B*41:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_33():
    result = parse("B*41:33")
    assert result.__class__ is Allele, f'Expected parse("B*41:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_34():
    result = parse("B*41:34")
    assert result.__class__ is Allele, f'Expected parse("B*41:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_35():
    result = parse("B*41:35")
    assert result.__class__ is Allele, f'Expected parse("B*41:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_36():
    result = parse("B*41:36")
    assert result.__class__ is Allele, f'Expected parse("B*41:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_37():
    result = parse("B*41:37")
    assert result.__class__ is Allele, f'Expected parse("B*41:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_38():
    result = parse("B*41:38")
    assert result.__class__ is Allele, f'Expected parse("B*41:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_39():
    result = parse("B*41:39")
    assert result.__class__ is Allele, f'Expected parse("B*41:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_40():
    result = parse("B*41:40")
    assert result.__class__ is Allele, f'Expected parse("B*41:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_41():
    result = parse("B*41:41")
    assert result.__class__ is Allele, f'Expected parse("B*41:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_42():
    result = parse("B*41:42")
    assert result.__class__ is Allele, f'Expected parse("B*41:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_43():
    result = parse("B*41:43")
    assert result.__class__ is Allele, f'Expected parse("B*41:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_44():
    result = parse("B*41:44")
    assert result.__class__ is Allele, f'Expected parse("B*41:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_45N():
    result = parse("B*41:45N")
    assert result.__class__ is Allele, f'Expected parse("B*41:45N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:45N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_46():
    result = parse("B*41:46")
    assert result.__class__ is Allele, f'Expected parse("B*41:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_47():
    result = parse("B*41:47")
    assert result.__class__ is Allele, f'Expected parse("B*41:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_48():
    result = parse("B*41:48")
    assert result.__class__ is Allele, f'Expected parse("B*41:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_49():
    result = parse("B*41:49")
    assert result.__class__ is Allele, f'Expected parse("B*41:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_50():
    result = parse("B*41:50")
    assert result.__class__ is Allele, f'Expected parse("B*41:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_51():
    result = parse("B*41:51")
    assert result.__class__ is Allele, f'Expected parse("B*41:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_52():
    result = parse("B*41:52")
    assert result.__class__ is Allele, f'Expected parse("B*41:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_53():
    result = parse("B*41:53")
    assert result.__class__ is Allele, f'Expected parse("B*41:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_54():
    result = parse("B*41:54")
    assert result.__class__ is Allele, f'Expected parse("B*41:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_55():
    result = parse("B*41:55")
    assert result.__class__ is Allele, f'Expected parse("B*41:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_56Q():
    result = parse("B*41:56Q")
    assert result.__class__ is Allele, f'Expected parse("B*41:56Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:56Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_57():
    result = parse("B*41:57")
    assert result.__class__ is Allele, f'Expected parse("B*41:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_58():
    result = parse("B*41:58")
    assert result.__class__ is Allele, f'Expected parse("B*41:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_59():
    result = parse("B*41:59")
    assert result.__class__ is Allele, f'Expected parse("B*41:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_60():
    result = parse("B*41:60")
    assert result.__class__ is Allele, f'Expected parse("B*41:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_61():
    result = parse("B*41:61")
    assert result.__class__ is Allele, f'Expected parse("B*41:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_62():
    result = parse("B*41:62")
    assert result.__class__ is Allele, f'Expected parse("B*41:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_63():
    result = parse("B*41:63")
    assert result.__class__ is Allele, f'Expected parse("B*41:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_64():
    result = parse("B*41:64")
    assert result.__class__ is Allele, f'Expected parse("B*41:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_65():
    result = parse("B*41:65")
    assert result.__class__ is Allele, f'Expected parse("B*41:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_41_66():
    result = parse("B*41:66")
    assert result.__class__ is Allele, f'Expected parse("B*41:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*41:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_01_01_01():
    result = parse("B*42:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*42:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*42:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_01_01_02():
    result = parse("B*42:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*42:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*42:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_01_02():
    result = parse("B*42:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*42:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*42:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_01_03():
    result = parse("B*42:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*42:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*42:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_01_04():
    result = parse("B*42:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*42:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*42:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_02_01_01():
    result = parse("B*42:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*42:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*42:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_02_01_02():
    result = parse("B*42:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*42:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*42:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_02_02():
    result = parse("B*42:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*42:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*42:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_04():
    result = parse("B*42:04")
    assert result.__class__ is Allele, f'Expected parse("B*42:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_05_01():
    result = parse("B*42:05:01")
    assert result.__class__ is Allele, f'Expected parse("B*42:05:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*42:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_05_02():
    result = parse("B*42:05:02")
    assert result.__class__ is Allele, f'Expected parse("B*42:05:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*42:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_06():
    result = parse("B*42:06")
    assert result.__class__ is Allele, f'Expected parse("B*42:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_07():
    result = parse("B*42:07")
    assert result.__class__ is Allele, f'Expected parse("B*42:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_08():
    result = parse("B*42:08")
    assert result.__class__ is Allele, f'Expected parse("B*42:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_09():
    result = parse("B*42:09")
    assert result.__class__ is Allele, f'Expected parse("B*42:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_10():
    result = parse("B*42:10")
    assert result.__class__ is Allele, f'Expected parse("B*42:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_11():
    result = parse("B*42:11")
    assert result.__class__ is Allele, f'Expected parse("B*42:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_12():
    result = parse("B*42:12")
    assert result.__class__ is Allele, f'Expected parse("B*42:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_13():
    result = parse("B*42:13")
    assert result.__class__ is Allele, f'Expected parse("B*42:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_14():
    result = parse("B*42:14")
    assert result.__class__ is Allele, f'Expected parse("B*42:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_15():
    result = parse("B*42:15")
    assert result.__class__ is Allele, f'Expected parse("B*42:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_16():
    result = parse("B*42:16")
    assert result.__class__ is Allele, f'Expected parse("B*42:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_17():
    result = parse("B*42:17")
    assert result.__class__ is Allele, f'Expected parse("B*42:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_18():
    result = parse("B*42:18")
    assert result.__class__ is Allele, f'Expected parse("B*42:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_19():
    result = parse("B*42:19")
    assert result.__class__ is Allele, f'Expected parse("B*42:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_20():
    result = parse("B*42:20")
    assert result.__class__ is Allele, f'Expected parse("B*42:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_21():
    result = parse("B*42:21")
    assert result.__class__ is Allele, f'Expected parse("B*42:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_22():
    result = parse("B*42:22")
    assert result.__class__ is Allele, f'Expected parse("B*42:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_23():
    result = parse("B*42:23")
    assert result.__class__ is Allele, f'Expected parse("B*42:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_24():
    result = parse("B*42:24")
    assert result.__class__ is Allele, f'Expected parse("B*42:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_25():
    result = parse("B*42:25")
    assert result.__class__ is Allele, f'Expected parse("B*42:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_26():
    result = parse("B*42:26")
    assert result.__class__ is Allele, f'Expected parse("B*42:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_27():
    result = parse("B*42:27")
    assert result.__class__ is Allele, f'Expected parse("B*42:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_42_28():
    result = parse("B*42:28")
    assert result.__class__ is Allele, f'Expected parse("B*42:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*42:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_01():
    result = parse("B*44:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_02S():
    result = parse("B*44:02:01:02S")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:02S") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:02S") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_03():
    result = parse("B*44:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_04():
    result = parse("B*44:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_05():
    result = parse("B*44:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_06():
    result = parse("B*44:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_07():
    result = parse("B*44:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_08():
    result = parse("B*44:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_09():
    result = parse("B*44:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_10():
    result = parse("B*44:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_11():
    result = parse("B*44:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_12():
    result = parse("B*44:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_13Q():
    result = parse("B*44:02:01:13Q")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:13Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:13Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_14():
    result = parse("B*44:02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_15():
    result = parse("B*44:02:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_16():
    result = parse("B*44:02:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_17():
    result = parse("B*44:02:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_18():
    result = parse("B*44:02:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_19():
    result = parse("B*44:02:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_20():
    result = parse("B*44:02:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_21():
    result = parse("B*44:02:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_22():
    result = parse("B*44:02:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_23():
    result = parse("B*44:02:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_24():
    result = parse("B*44:02:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_25():
    result = parse("B*44:02:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_26():
    result = parse("B*44:02:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_27():
    result = parse("B*44:02:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_28():
    result = parse("B*44:02:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_29():
    result = parse("B*44:02:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_30():
    result = parse("B*44:02:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_31():
    result = parse("B*44:02:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_32():
    result = parse("B*44:02:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_33():
    result = parse("B*44:02:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_34():
    result = parse("B*44:02:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_35():
    result = parse("B*44:02:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_36():
    result = parse("B*44:02:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_37():
    result = parse("B*44:02:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_38():
    result = parse("B*44:02:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_39():
    result = parse("B*44:02:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_40():
    result = parse("B*44:02:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_41():
    result = parse("B*44:02:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_42():
    result = parse("B*44:02:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_01_43():
    result = parse("B*44:02:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:02:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:02:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_02():
    result = parse("B*44:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_03():
    result = parse("B*44:02:03")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_04():
    result = parse("B*44:02:04")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_05():
    result = parse("B*44:02:05")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_06():
    result = parse("B*44:02:06")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_07():
    result = parse("B*44:02:07")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_08():
    result = parse("B*44:02:08")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_09():
    result = parse("B*44:02:09")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_10():
    result = parse("B*44:02:10")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_11():
    result = parse("B*44:02:11")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_12():
    result = parse("B*44:02:12")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_13():
    result = parse("B*44:02:13")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_14():
    result = parse("B*44:02:14")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_15():
    result = parse("B*44:02:15")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_16():
    result = parse("B*44:02:16")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_17():
    result = parse("B*44:02:17")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_18():
    result = parse("B*44:02:18")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_19():
    result = parse("B*44:02:19")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_20():
    result = parse("B*44:02:20")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_21():
    result = parse("B*44:02:21")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_22():
    result = parse("B*44:02:22")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_23():
    result = parse("B*44:02:23")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_24():
    result = parse("B*44:02:24")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_25():
    result = parse("B*44:02:25")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_26():
    result = parse("B*44:02:26")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_27():
    result = parse("B*44:02:27")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_28():
    result = parse("B*44:02:28")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_29():
    result = parse("B*44:02:29")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_30():
    result = parse("B*44:02:30")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_31():
    result = parse("B*44:02:31")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_32():
    result = parse("B*44:02:32")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_33():
    result = parse("B*44:02:33")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_34():
    result = parse("B*44:02:34")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_35():
    result = parse("B*44:02:35")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_36():
    result = parse("B*44:02:36")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_37():
    result = parse("B*44:02:37")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_38():
    result = parse("B*44:02:38")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_39():
    result = parse("B*44:02:39")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_40():
    result = parse("B*44:02:40")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_41():
    result = parse("B*44:02:41")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_42():
    result = parse("B*44:02:42")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_43():
    result = parse("B*44:02:43")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_44():
    result = parse("B*44:02:44")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_45():
    result = parse("B*44:02:45")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_46():
    result = parse("B*44:02:46")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_47():
    result = parse("B*44:02:47")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_48():
    result = parse("B*44:02:48")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_49():
    result = parse("B*44:02:49")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_50():
    result = parse("B*44:02:50")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_51():
    result = parse("B*44:02:51")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_52():
    result = parse("B*44:02:52")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_53():
    result = parse("B*44:02:53")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_54():
    result = parse("B*44:02:54")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_55():
    result = parse("B*44:02:55")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_56():
    result = parse("B*44:02:56")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_57():
    result = parse("B*44:02:57")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_58():
    result = parse("B*44:02:58")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_59():
    result = parse("B*44:02:59")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_60():
    result = parse("B*44:02:60")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_61():
    result = parse("B*44:02:61")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_62():
    result = parse("B*44:02:62")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_63():
    result = parse("B*44:02:63")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_64():
    result = parse("B*44:02:64")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_65():
    result = parse("B*44:02:65")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_02_66():
    result = parse("B*44:02:66")
    assert result.__class__ is Allele, f'Expected parse("B*44:02:66") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:02:66") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_01():
    result = parse("B*44:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_02():
    result = parse("B*44:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_03():
    result = parse("B*44:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_04():
    result = parse("B*44:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_05():
    result = parse("B*44:03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_06():
    result = parse("B*44:03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_07():
    result = parse("B*44:03:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_08():
    result = parse("B*44:03:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_09():
    result = parse("B*44:03:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_10():
    result = parse("B*44:03:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_11():
    result = parse("B*44:03:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_12():
    result = parse("B*44:03:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_13():
    result = parse("B*44:03:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_14():
    result = parse("B*44:03:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_15():
    result = parse("B*44:03:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_16():
    result = parse("B*44:03:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_17():
    result = parse("B*44:03:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_18():
    result = parse("B*44:03:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_19():
    result = parse("B*44:03:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_20():
    result = parse("B*44:03:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_21():
    result = parse("B*44:03:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_22():
    result = parse("B*44:03:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_23():
    result = parse("B*44:03:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_24():
    result = parse("B*44:03:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_25():
    result = parse("B*44:03:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_26():
    result = parse("B*44:03:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_27():
    result = parse("B*44:03:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_28():
    result = parse("B*44:03:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_29():
    result = parse("B*44:03:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_30():
    result = parse("B*44:03:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_31():
    result = parse("B*44:03:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_32():
    result = parse("B*44:03:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_33():
    result = parse("B*44:03:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_34():
    result = parse("B*44:03:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_01_35():
    result = parse("B*44:03:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_02_01():
    result = parse("B*44:03:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_02_02():
    result = parse("B*44:03:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:03:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:03:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_03():
    result = parse("B*44:03:03")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_04():
    result = parse("B*44:03:04")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_05():
    result = parse("B*44:03:05")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_06():
    result = parse("B*44:03:06")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_07():
    result = parse("B*44:03:07")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_08():
    result = parse("B*44:03:08")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_09():
    result = parse("B*44:03:09")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_10():
    result = parse("B*44:03:10")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_11():
    result = parse("B*44:03:11")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_12():
    result = parse("B*44:03:12")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_13():
    result = parse("B*44:03:13")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_14():
    result = parse("B*44:03:14")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_15():
    result = parse("B*44:03:15")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_16():
    result = parse("B*44:03:16")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_17():
    result = parse("B*44:03:17")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_18():
    result = parse("B*44:03:18")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_19():
    result = parse("B*44:03:19")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_20():
    result = parse("B*44:03:20")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_21():
    result = parse("B*44:03:21")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_22():
    result = parse("B*44:03:22")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_23():
    result = parse("B*44:03:23")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_24():
    result = parse("B*44:03:24")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_25():
    result = parse("B*44:03:25")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_26():
    result = parse("B*44:03:26")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_27():
    result = parse("B*44:03:27")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_28():
    result = parse("B*44:03:28")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_29():
    result = parse("B*44:03:29")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_30():
    result = parse("B*44:03:30")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_31():
    result = parse("B*44:03:31")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_32():
    result = parse("B*44:03:32")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_33():
    result = parse("B*44:03:33")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_34():
    result = parse("B*44:03:34")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_35():
    result = parse("B*44:03:35")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_36():
    result = parse("B*44:03:36")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_37():
    result = parse("B*44:03:37")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_38():
    result = parse("B*44:03:38")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_39():
    result = parse("B*44:03:39")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_40():
    result = parse("B*44:03:40")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_41():
    result = parse("B*44:03:41")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_42():
    result = parse("B*44:03:42")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_43():
    result = parse("B*44:03:43")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_44():
    result = parse("B*44:03:44")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_45():
    result = parse("B*44:03:45")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_46():
    result = parse("B*44:03:46")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_47():
    result = parse("B*44:03:47")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_48():
    result = parse("B*44:03:48")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_49():
    result = parse("B*44:03:49")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_50():
    result = parse("B*44:03:50")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_51():
    result = parse("B*44:03:51")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_52():
    result = parse("B*44:03:52")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_53():
    result = parse("B*44:03:53")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_54():
    result = parse("B*44:03:54")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_55():
    result = parse("B*44:03:55")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_56():
    result = parse("B*44:03:56")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_57():
    result = parse("B*44:03:57")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_03_58():
    result = parse("B*44:03:58")
    assert result.__class__ is Allele, f'Expected parse("B*44:03:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:03:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_04():
    result = parse("B*44:04")
    assert result.__class__ is Allele, f'Expected parse("B*44:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_05_01_01():
    result = parse("B*44:05:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:05:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:05:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_05_01_02():
    result = parse("B*44:05:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:05:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:05:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_05_01_03():
    result = parse("B*44:05:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:05:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:05:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_05_01_04():
    result = parse("B*44:05:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:05:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:05:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_05_02():
    result = parse("B*44:05:02")
    assert result.__class__ is Allele, f'Expected parse("B*44:05:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_05_03():
    result = parse("B*44:05:03")
    assert result.__class__ is Allele, f'Expected parse("B*44:05:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:05:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_05_04():
    result = parse("B*44:05:04")
    assert result.__class__ is Allele, f'Expected parse("B*44:05:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:05:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_06():
    result = parse("B*44:06")
    assert result.__class__ is Allele, f'Expected parse("B*44:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_07():
    result = parse("B*44:07")
    assert result.__class__ is Allele, f'Expected parse("B*44:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_08():
    result = parse("B*44:08")
    assert result.__class__ is Allele, f'Expected parse("B*44:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_09():
    result = parse("B*44:09")
    assert result.__class__ is Allele, f'Expected parse("B*44:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_10():
    result = parse("B*44:10")
    assert result.__class__ is Allele, f'Expected parse("B*44:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_100():
    result = parse("B*44:100")
    assert result.__class__ is Allele, f'Expected parse("B*44:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_101():
    result = parse("B*44:101")
    assert result.__class__ is Allele, f'Expected parse("B*44:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_102():
    result = parse("B*44:102")
    assert result.__class__ is Allele, f'Expected parse("B*44:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_103():
    result = parse("B*44:103")
    assert result.__class__ is Allele, f'Expected parse("B*44:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_104():
    result = parse("B*44:104")
    assert result.__class__ is Allele, f'Expected parse("B*44:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_105():
    result = parse("B*44:105")
    assert result.__class__ is Allele, f'Expected parse("B*44:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_106():
    result = parse("B*44:106")
    assert result.__class__ is Allele, f'Expected parse("B*44:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_107():
    result = parse("B*44:107")
    assert result.__class__ is Allele, f'Expected parse("B*44:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_108N():
    result = parse("B*44:108N")
    assert result.__class__ is Allele, f'Expected parse("B*44:108N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:108N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_109():
    result = parse("B*44:109")
    assert result.__class__ is Allele, f'Expected parse("B*44:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_11():
    result = parse("B*44:11")
    assert result.__class__ is Allele, f'Expected parse("B*44:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_110():
    result = parse("B*44:110")
    assert result.__class__ is Allele, f'Expected parse("B*44:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_111():
    result = parse("B*44:111")
    assert result.__class__ is Allele, f'Expected parse("B*44:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_112():
    result = parse("B*44:112")
    assert result.__class__ is Allele, f'Expected parse("B*44:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_113():
    result = parse("B*44:113")
    assert result.__class__ is Allele, f'Expected parse("B*44:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_114():
    result = parse("B*44:114")
    assert result.__class__ is Allele, f'Expected parse("B*44:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_115():
    result = parse("B*44:115")
    assert result.__class__ is Allele, f'Expected parse("B*44:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_116():
    result = parse("B*44:116")
    assert result.__class__ is Allele, f'Expected parse("B*44:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_117():
    result = parse("B*44:117")
    assert result.__class__ is Allele, f'Expected parse("B*44:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_118():
    result = parse("B*44:118")
    assert result.__class__ is Allele, f'Expected parse("B*44:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_119():
    result = parse("B*44:119")
    assert result.__class__ is Allele, f'Expected parse("B*44:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_12():
    result = parse("B*44:12")
    assert result.__class__ is Allele, f'Expected parse("B*44:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_120():
    result = parse("B*44:120")
    assert result.__class__ is Allele, f'Expected parse("B*44:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_121():
    result = parse("B*44:121")
    assert result.__class__ is Allele, f'Expected parse("B*44:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_122():
    result = parse("B*44:122")
    assert result.__class__ is Allele, f'Expected parse("B*44:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_123():
    result = parse("B*44:123")
    assert result.__class__ is Allele, f'Expected parse("B*44:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_124():
    result = parse("B*44:124")
    assert result.__class__ is Allele, f'Expected parse("B*44:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_125():
    result = parse("B*44:125")
    assert result.__class__ is Allele, f'Expected parse("B*44:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_126_01():
    result = parse("B*44:126:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:126:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:126:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_126_02():
    result = parse("B*44:126:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:126:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:126:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_127():
    result = parse("B*44:127")
    assert result.__class__ is Allele, f'Expected parse("B*44:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_128_01():
    result = parse("B*44:128:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:128:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:128:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_128_02():
    result = parse("B*44:128:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:128:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:128:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_129():
    result = parse("B*44:129")
    assert result.__class__ is Allele, f'Expected parse("B*44:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_13():
    result = parse("B*44:13")
    assert result.__class__ is Allele, f'Expected parse("B*44:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_130():
    result = parse("B*44:130")
    assert result.__class__ is Allele, f'Expected parse("B*44:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_131():
    result = parse("B*44:131")
    assert result.__class__ is Allele, f'Expected parse("B*44:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_132():
    result = parse("B*44:132")
    assert result.__class__ is Allele, f'Expected parse("B*44:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_133():
    result = parse("B*44:133")
    assert result.__class__ is Allele, f'Expected parse("B*44:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_134():
    result = parse("B*44:134")
    assert result.__class__ is Allele, f'Expected parse("B*44:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_135():
    result = parse("B*44:135")
    assert result.__class__ is Allele, f'Expected parse("B*44:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_136():
    result = parse("B*44:136")
    assert result.__class__ is Allele, f'Expected parse("B*44:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_137():
    result = parse("B*44:137")
    assert result.__class__ is Allele, f'Expected parse("B*44:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_138Q():
    result = parse("B*44:138Q")
    assert result.__class__ is Allele, f'Expected parse("B*44:138Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:138Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_139():
    result = parse("B*44:139")
    assert result.__class__ is Allele, f'Expected parse("B*44:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_14():
    result = parse("B*44:14")
    assert result.__class__ is Allele, f'Expected parse("B*44:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_140():
    result = parse("B*44:140")
    assert result.__class__ is Allele, f'Expected parse("B*44:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_141():
    result = parse("B*44:141")
    assert result.__class__ is Allele, f'Expected parse("B*44:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_142():
    result = parse("B*44:142")
    assert result.__class__ is Allele, f'Expected parse("B*44:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_143():
    result = parse("B*44:143")
    assert result.__class__ is Allele, f'Expected parse("B*44:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_144():
    result = parse("B*44:144")
    assert result.__class__ is Allele, f'Expected parse("B*44:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_145():
    result = parse("B*44:145")
    assert result.__class__ is Allele, f'Expected parse("B*44:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_146():
    result = parse("B*44:146")
    assert result.__class__ is Allele, f'Expected parse("B*44:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_147():
    result = parse("B*44:147")
    assert result.__class__ is Allele, f'Expected parse("B*44:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_148():
    result = parse("B*44:148")
    assert result.__class__ is Allele, f'Expected parse("B*44:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_149N():
    result = parse("B*44:149N")
    assert result.__class__ is Allele, f'Expected parse("B*44:149N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:149N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_150():
    result = parse("B*44:150")
    assert result.__class__ is Allele, f'Expected parse("B*44:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_151():
    result = parse("B*44:151")
    assert result.__class__ is Allele, f'Expected parse("B*44:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_152():
    result = parse("B*44:152")
    assert result.__class__ is Allele, f'Expected parse("B*44:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_153():
    result = parse("B*44:153")
    assert result.__class__ is Allele, f'Expected parse("B*44:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_154():
    result = parse("B*44:154")
    assert result.__class__ is Allele, f'Expected parse("B*44:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_155():
    result = parse("B*44:155")
    assert result.__class__ is Allele, f'Expected parse("B*44:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_156():
    result = parse("B*44:156")
    assert result.__class__ is Allele, f'Expected parse("B*44:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_157():
    result = parse("B*44:157")
    assert result.__class__ is Allele, f'Expected parse("B*44:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_158():
    result = parse("B*44:158")
    assert result.__class__ is Allele, f'Expected parse("B*44:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_159():
    result = parse("B*44:159")
    assert result.__class__ is Allele, f'Expected parse("B*44:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_15_01_01():
    result = parse("B*44:15:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:15:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:15:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_15_01_02():
    result = parse("B*44:15:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:15:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:15:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_16():
    result = parse("B*44:16")
    assert result.__class__ is Allele, f'Expected parse("B*44:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_160Q():
    result = parse("B*44:160Q")
    assert result.__class__ is Allele, f'Expected parse("B*44:160Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:160Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_161():
    result = parse("B*44:161")
    assert result.__class__ is Allele, f'Expected parse("B*44:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_162():
    result = parse("B*44:162")
    assert result.__class__ is Allele, f'Expected parse("B*44:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_163_01():
    result = parse("B*44:163:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:163:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:163:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_163_02():
    result = parse("B*44:163:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:163:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:163:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_164():
    result = parse("B*44:164")
    assert result.__class__ is Allele, f'Expected parse("B*44:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_165():
    result = parse("B*44:165")
    assert result.__class__ is Allele, f'Expected parse("B*44:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_166():
    result = parse("B*44:166")
    assert result.__class__ is Allele, f'Expected parse("B*44:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_167():
    result = parse("B*44:167")
    assert result.__class__ is Allele, f'Expected parse("B*44:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_168():
    result = parse("B*44:168")
    assert result.__class__ is Allele, f'Expected parse("B*44:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_169():
    result = parse("B*44:169")
    assert result.__class__ is Allele, f'Expected parse("B*44:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_17():
    result = parse("B*44:17")
    assert result.__class__ is Allele, f'Expected parse("B*44:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_170():
    result = parse("B*44:170")
    assert result.__class__ is Allele, f'Expected parse("B*44:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_171N():
    result = parse("B*44:171N")
    assert result.__class__ is Allele, f'Expected parse("B*44:171N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:171N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_172():
    result = parse("B*44:172")
    assert result.__class__ is Allele, f'Expected parse("B*44:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_173():
    result = parse("B*44:173")
    assert result.__class__ is Allele, f'Expected parse("B*44:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_174():
    result = parse("B*44:174")
    assert result.__class__ is Allele, f'Expected parse("B*44:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_175():
    result = parse("B*44:175")
    assert result.__class__ is Allele, f'Expected parse("B*44:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_176():
    result = parse("B*44:176")
    assert result.__class__ is Allele, f'Expected parse("B*44:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_177():
    result = parse("B*44:177")
    assert result.__class__ is Allele, f'Expected parse("B*44:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_178():
    result = parse("B*44:178")
    assert result.__class__ is Allele, f'Expected parse("B*44:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_179():
    result = parse("B*44:179")
    assert result.__class__ is Allele, f'Expected parse("B*44:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_18():
    result = parse("B*44:18")
    assert result.__class__ is Allele, f'Expected parse("B*44:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_180():
    result = parse("B*44:180")
    assert result.__class__ is Allele, f'Expected parse("B*44:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_181():
    result = parse("B*44:181")
    assert result.__class__ is Allele, f'Expected parse("B*44:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_182():
    result = parse("B*44:182")
    assert result.__class__ is Allele, f'Expected parse("B*44:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_183():
    result = parse("B*44:183")
    assert result.__class__ is Allele, f'Expected parse("B*44:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_184():
    result = parse("B*44:184")
    assert result.__class__ is Allele, f'Expected parse("B*44:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_185():
    result = parse("B*44:185")
    assert result.__class__ is Allele, f'Expected parse("B*44:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_186_01():
    result = parse("B*44:186:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:186:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:186:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_186_02():
    result = parse("B*44:186:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:186:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:186:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_187():
    result = parse("B*44:187")
    assert result.__class__ is Allele, f'Expected parse("B*44:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_188():
    result = parse("B*44:188")
    assert result.__class__ is Allele, f'Expected parse("B*44:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_189():
    result = parse("B*44:189")
    assert result.__class__ is Allele, f'Expected parse("B*44:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_190():
    result = parse("B*44:190")
    assert result.__class__ is Allele, f'Expected parse("B*44:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_191():
    result = parse("B*44:191")
    assert result.__class__ is Allele, f'Expected parse("B*44:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_192_01():
    result = parse("B*44:192:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:192:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:192:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_192_02():
    result = parse("B*44:192:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:192:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:192:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_192_03():
    result = parse("B*44:192:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:192:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:192:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_192_04():
    result = parse("B*44:192:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:192:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:192:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_193():
    result = parse("B*44:193")
    assert result.__class__ is Allele, f'Expected parse("B*44:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_194():
    result = parse("B*44:194")
    assert result.__class__ is Allele, f'Expected parse("B*44:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_195N():
    result = parse("B*44:195N")
    assert result.__class__ is Allele, f'Expected parse("B*44:195N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:195N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_196():
    result = parse("B*44:196")
    assert result.__class__ is Allele, f'Expected parse("B*44:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_197():
    result = parse("B*44:197")
    assert result.__class__ is Allele, f'Expected parse("B*44:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_198N():
    result = parse("B*44:198N")
    assert result.__class__ is Allele, f'Expected parse("B*44:198N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:198N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_199():
    result = parse("B*44:199")
    assert result.__class__ is Allele, f'Expected parse("B*44:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_19N():
    result = parse("B*44:19N")
    assert result.__class__ is Allele, f'Expected parse("B*44:19N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:19N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_20():
    result = parse("B*44:20")
    assert result.__class__ is Allele, f'Expected parse("B*44:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_200():
    result = parse("B*44:200")
    assert result.__class__ is Allele, f'Expected parse("B*44:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_201():
    result = parse("B*44:201")
    assert result.__class__ is Allele, f'Expected parse("B*44:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_202():
    result = parse("B*44:202")
    assert result.__class__ is Allele, f'Expected parse("B*44:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_203_01():
    result = parse("B*44:203:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:203:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:203:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_203_02():
    result = parse("B*44:203:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:203:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:203:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_204_01():
    result = parse("B*44:204:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:204:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:204:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_204_02():
    result = parse("B*44:204:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:204:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:204:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_205_01():
    result = parse("B*44:205:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:205:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:205:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_205_02():
    result = parse("B*44:205:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:205:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:205:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_206():
    result = parse("B*44:206")
    assert result.__class__ is Allele, f'Expected parse("B*44:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_207():
    result = parse("B*44:207")
    assert result.__class__ is Allele, f'Expected parse("B*44:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_208():
    result = parse("B*44:208")
    assert result.__class__ is Allele, f'Expected parse("B*44:208") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_209():
    result = parse("B*44:209")
    assert result.__class__ is Allele, f'Expected parse("B*44:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_21():
    result = parse("B*44:21")
    assert result.__class__ is Allele, f'Expected parse("B*44:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_210_01():
    result = parse("B*44:210:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:210:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:210:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_210_02():
    result = parse("B*44:210:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:210:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:210:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_211():
    result = parse("B*44:211")
    assert result.__class__ is Allele, f'Expected parse("B*44:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_212():
    result = parse("B*44:212")
    assert result.__class__ is Allele, f'Expected parse("B*44:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_213():
    result = parse("B*44:213")
    assert result.__class__ is Allele, f'Expected parse("B*44:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_214():
    result = parse("B*44:214")
    assert result.__class__ is Allele, f'Expected parse("B*44:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_215():
    result = parse("B*44:215")
    assert result.__class__ is Allele, f'Expected parse("B*44:215") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_216():
    result = parse("B*44:216")
    assert result.__class__ is Allele, f'Expected parse("B*44:216") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_217N():
    result = parse("B*44:217N")
    assert result.__class__ is Allele, f'Expected parse("B*44:217N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:217N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_218():
    result = parse("B*44:218")
    assert result.__class__ is Allele, f'Expected parse("B*44:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_219():
    result = parse("B*44:219")
    assert result.__class__ is Allele, f'Expected parse("B*44:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_22():
    result = parse("B*44:22")
    assert result.__class__ is Allele, f'Expected parse("B*44:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_220():
    result = parse("B*44:220")
    assert result.__class__ is Allele, f'Expected parse("B*44:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_221():
    result = parse("B*44:221")
    assert result.__class__ is Allele, f'Expected parse("B*44:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_222():
    result = parse("B*44:222")
    assert result.__class__ is Allele, f'Expected parse("B*44:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_223():
    result = parse("B*44:223")
    assert result.__class__ is Allele, f'Expected parse("B*44:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_224():
    result = parse("B*44:224")
    assert result.__class__ is Allele, f'Expected parse("B*44:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_225():
    result = parse("B*44:225")
    assert result.__class__ is Allele, f'Expected parse("B*44:225") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_226():
    result = parse("B*44:226")
    assert result.__class__ is Allele, f'Expected parse("B*44:226") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_227():
    result = parse("B*44:227")
    assert result.__class__ is Allele, f'Expected parse("B*44:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_228():
    result = parse("B*44:228")
    assert result.__class__ is Allele, f'Expected parse("B*44:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_229():
    result = parse("B*44:229")
    assert result.__class__ is Allele, f'Expected parse("B*44:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_230():
    result = parse("B*44:230")
    assert result.__class__ is Allele, f'Expected parse("B*44:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_231():
    result = parse("B*44:231")
    assert result.__class__ is Allele, f'Expected parse("B*44:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_232():
    result = parse("B*44:232")
    assert result.__class__ is Allele, f'Expected parse("B*44:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_233():
    result = parse("B*44:233")
    assert result.__class__ is Allele, f'Expected parse("B*44:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_234():
    result = parse("B*44:234")
    assert result.__class__ is Allele, f'Expected parse("B*44:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_235():
    result = parse("B*44:235")
    assert result.__class__ is Allele, f'Expected parse("B*44:235") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_236():
    result = parse("B*44:236")
    assert result.__class__ is Allele, f'Expected parse("B*44:236") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_237N():
    result = parse("B*44:237N")
    assert result.__class__ is Allele, f'Expected parse("B*44:237N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:237N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_238():
    result = parse("B*44:238")
    assert result.__class__ is Allele, f'Expected parse("B*44:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_239():
    result = parse("B*44:239")
    assert result.__class__ is Allele, f'Expected parse("B*44:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_23N():
    result = parse("B*44:23N")
    assert result.__class__ is Allele, f'Expected parse("B*44:23N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:23N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_24():
    result = parse("B*44:24")
    assert result.__class__ is Allele, f'Expected parse("B*44:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_240():
    result = parse("B*44:240")
    assert result.__class__ is Allele, f'Expected parse("B*44:240") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_241():
    result = parse("B*44:241")
    assert result.__class__ is Allele, f'Expected parse("B*44:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_242():
    result = parse("B*44:242")
    assert result.__class__ is Allele, f'Expected parse("B*44:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_243():
    result = parse("B*44:243")
    assert result.__class__ is Allele, f'Expected parse("B*44:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_244():
    result = parse("B*44:244")
    assert result.__class__ is Allele, f'Expected parse("B*44:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_245():
    result = parse("B*44:245")
    assert result.__class__ is Allele, f'Expected parse("B*44:245") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_247():
    result = parse("B*44:247")
    assert result.__class__ is Allele, f'Expected parse("B*44:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_248():
    result = parse("B*44:248")
    assert result.__class__ is Allele, f'Expected parse("B*44:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_249():
    result = parse("B*44:249")
    assert result.__class__ is Allele, f'Expected parse("B*44:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_25():
    result = parse("B*44:25")
    assert result.__class__ is Allele, f'Expected parse("B*44:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_250():
    result = parse("B*44:250")
    assert result.__class__ is Allele, f'Expected parse("B*44:250") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_251():
    result = parse("B*44:251")
    assert result.__class__ is Allele, f'Expected parse("B*44:251") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_252():
    result = parse("B*44:252")
    assert result.__class__ is Allele, f'Expected parse("B*44:252") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_253():
    result = parse("B*44:253")
    assert result.__class__ is Allele, f'Expected parse("B*44:253") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_254():
    result = parse("B*44:254")
    assert result.__class__ is Allele, f'Expected parse("B*44:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_255():
    result = parse("B*44:255")
    assert result.__class__ is Allele, f'Expected parse("B*44:255") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_256():
    result = parse("B*44:256")
    assert result.__class__ is Allele, f'Expected parse("B*44:256") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_257():
    result = parse("B*44:257")
    assert result.__class__ is Allele, f'Expected parse("B*44:257") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_258():
    result = parse("B*44:258")
    assert result.__class__ is Allele, f'Expected parse("B*44:258") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_259():
    result = parse("B*44:259")
    assert result.__class__ is Allele, f'Expected parse("B*44:259") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_26():
    result = parse("B*44:26")
    assert result.__class__ is Allele, f'Expected parse("B*44:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_260():
    result = parse("B*44:260")
    assert result.__class__ is Allele, f'Expected parse("B*44:260") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_261():
    result = parse("B*44:261")
    assert result.__class__ is Allele, f'Expected parse("B*44:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_262():
    result = parse("B*44:262")
    assert result.__class__ is Allele, f'Expected parse("B*44:262") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_263():
    result = parse("B*44:263")
    assert result.__class__ is Allele, f'Expected parse("B*44:263") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_264():
    result = parse("B*44:264")
    assert result.__class__ is Allele, f'Expected parse("B*44:264") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_265():
    result = parse("B*44:265")
    assert result.__class__ is Allele, f'Expected parse("B*44:265") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_266_01():
    result = parse("B*44:266:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:266:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:266:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_266_02():
    result = parse("B*44:266:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:266:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:266:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_267N():
    result = parse("B*44:267N")
    assert result.__class__ is Allele, f'Expected parse("B*44:267N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:267N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_268():
    result = parse("B*44:268")
    assert result.__class__ is Allele, f'Expected parse("B*44:268") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_269():
    result = parse("B*44:269")
    assert result.__class__ is Allele, f'Expected parse("B*44:269") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_270_01():
    result = parse("B*44:270:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:270:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:270:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_270_02():
    result = parse("B*44:270:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:270:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:270:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_271():
    result = parse("B*44:271")
    assert result.__class__ is Allele, f'Expected parse("B*44:271") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_272():
    result = parse("B*44:272")
    assert result.__class__ is Allele, f'Expected parse("B*44:272") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_273():
    result = parse("B*44:273")
    assert result.__class__ is Allele, f'Expected parse("B*44:273") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_274():
    result = parse("B*44:274")
    assert result.__class__ is Allele, f'Expected parse("B*44:274") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_275():
    result = parse("B*44:275")
    assert result.__class__ is Allele, f'Expected parse("B*44:275") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_276():
    result = parse("B*44:276")
    assert result.__class__ is Allele, f'Expected parse("B*44:276") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_277():
    result = parse("B*44:277")
    assert result.__class__ is Allele, f'Expected parse("B*44:277") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_278():
    result = parse("B*44:278")
    assert result.__class__ is Allele, f'Expected parse("B*44:278") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_279():
    result = parse("B*44:279")
    assert result.__class__ is Allele, f'Expected parse("B*44:279") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_27_01_01():
    result = parse("B*44:27:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:27:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:27:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_27_01_02():
    result = parse("B*44:27:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:27:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:27:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_27_02():
    result = parse("B*44:27:02")
    assert result.__class__ is Allele, f'Expected parse("B*44:27:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:27:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_27_03():
    result = parse("B*44:27:03")
    assert result.__class__ is Allele, f'Expected parse("B*44:27:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:27:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_280():
    result = parse("B*44:280")
    assert result.__class__ is Allele, f'Expected parse("B*44:280") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_281_01():
    result = parse("B*44:281:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:281:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:281:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_281_02():
    result = parse("B*44:281:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:281:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:281:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_282():
    result = parse("B*44:282")
    assert result.__class__ is Allele, f'Expected parse("B*44:282") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_283():
    result = parse("B*44:283")
    assert result.__class__ is Allele, f'Expected parse("B*44:283") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_284():
    result = parse("B*44:284")
    assert result.__class__ is Allele, f'Expected parse("B*44:284") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_285():
    result = parse("B*44:285")
    assert result.__class__ is Allele, f'Expected parse("B*44:285") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_286():
    result = parse("B*44:286")
    assert result.__class__ is Allele, f'Expected parse("B*44:286") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_287():
    result = parse("B*44:287")
    assert result.__class__ is Allele, f'Expected parse("B*44:287") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:287") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_288():
    result = parse("B*44:288")
    assert result.__class__ is Allele, f'Expected parse("B*44:288") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_289():
    result = parse("B*44:289")
    assert result.__class__ is Allele, f'Expected parse("B*44:289") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_28_01():
    result = parse("B*44:28:01")
    assert result.__class__ is Allele, f'Expected parse("B*44:28:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:28:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_28_02():
    result = parse("B*44:28:02")
    assert result.__class__ is Allele, f'Expected parse("B*44:28:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:28:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_29():
    result = parse("B*44:29")
    assert result.__class__ is Allele, f'Expected parse("B*44:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_290():
    result = parse("B*44:290")
    assert result.__class__ is Allele, f'Expected parse("B*44:290") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_291():
    result = parse("B*44:291")
    assert result.__class__ is Allele, f'Expected parse("B*44:291") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_292():
    result = parse("B*44:292")
    assert result.__class__ is Allele, f'Expected parse("B*44:292") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_293():
    result = parse("B*44:293")
    assert result.__class__ is Allele, f'Expected parse("B*44:293") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_294():
    result = parse("B*44:294")
    assert result.__class__ is Allele, f'Expected parse("B*44:294") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_295():
    result = parse("B*44:295")
    assert result.__class__ is Allele, f'Expected parse("B*44:295") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_296():
    result = parse("B*44:296")
    assert result.__class__ is Allele, f'Expected parse("B*44:296") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_297():
    result = parse("B*44:297")
    assert result.__class__ is Allele, f'Expected parse("B*44:297") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_298():
    result = parse("B*44:298")
    assert result.__class__ is Allele, f'Expected parse("B*44:298") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_299():
    result = parse("B*44:299")
    assert result.__class__ is Allele, f'Expected parse("B*44:299") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_30():
    result = parse("B*44:30")
    assert result.__class__ is Allele, f'Expected parse("B*44:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_300():
    result = parse("B*44:300")
    assert result.__class__ is Allele, f'Expected parse("B*44:300") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_301():
    result = parse("B*44:301")
    assert result.__class__ is Allele, f'Expected parse("B*44:301") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_302():
    result = parse("B*44:302")
    assert result.__class__ is Allele, f'Expected parse("B*44:302") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_303N():
    result = parse("B*44:303N")
    assert result.__class__ is Allele, f'Expected parse("B*44:303N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:303N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_304():
    result = parse("B*44:304")
    assert result.__class__ is Allele, f'Expected parse("B*44:304") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:304") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_305():
    result = parse("B*44:305")
    assert result.__class__ is Allele, f'Expected parse("B*44:305") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_306N():
    result = parse("B*44:306N")
    assert result.__class__ is Allele, f'Expected parse("B*44:306N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:306N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_307():
    result = parse("B*44:307")
    assert result.__class__ is Allele, f'Expected parse("B*44:307") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_308():
    result = parse("B*44:308")
    assert result.__class__ is Allele, f'Expected parse("B*44:308") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:308") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_309N():
    result = parse("B*44:309N")
    assert result.__class__ is Allele, f'Expected parse("B*44:309N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:309N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_31():
    result = parse("B*44:31")
    assert result.__class__ is Allele, f'Expected parse("B*44:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_310N():
    result = parse("B*44:310N")
    assert result.__class__ is Allele, f'Expected parse("B*44:310N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:310N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_311():
    result = parse("B*44:311")
    assert result.__class__ is Allele, f'Expected parse("B*44:311") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:311") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_312():
    result = parse("B*44:312")
    assert result.__class__ is Allele, f'Expected parse("B*44:312") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:312") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_313():
    result = parse("B*44:313")
    assert result.__class__ is Allele, f'Expected parse("B*44:313") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:313") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_314N():
    result = parse("B*44:314N")
    assert result.__class__ is Allele, f'Expected parse("B*44:314N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:314N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_315():
    result = parse("B*44:315")
    assert result.__class__ is Allele, f'Expected parse("B*44:315") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:315") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_316():
    result = parse("B*44:316")
    assert result.__class__ is Allele, f'Expected parse("B*44:316") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:316") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_317():
    result = parse("B*44:317")
    assert result.__class__ is Allele, f'Expected parse("B*44:317") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:317") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_318():
    result = parse("B*44:318")
    assert result.__class__ is Allele, f'Expected parse("B*44:318") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:318") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_319():
    result = parse("B*44:319")
    assert result.__class__ is Allele, f'Expected parse("B*44:319") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_32():
    result = parse("B*44:32")
    assert result.__class__ is Allele, f'Expected parse("B*44:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_320():
    result = parse("B*44:320")
    assert result.__class__ is Allele, f'Expected parse("B*44:320") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:320") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_321():
    result = parse("B*44:321")
    assert result.__class__ is Allele, f'Expected parse("B*44:321") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:321") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_322():
    result = parse("B*44:322")
    assert result.__class__ is Allele, f'Expected parse("B*44:322") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:322") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_323():
    result = parse("B*44:323")
    assert result.__class__ is Allele, f'Expected parse("B*44:323") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:323") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_324():
    result = parse("B*44:324")
    assert result.__class__ is Allele, f'Expected parse("B*44:324") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:324") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_325():
    result = parse("B*44:325")
    assert result.__class__ is Allele, f'Expected parse("B*44:325") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:325") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_326():
    result = parse("B*44:326")
    assert result.__class__ is Allele, f'Expected parse("B*44:326") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:326") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_327():
    result = parse("B*44:327")
    assert result.__class__ is Allele, f'Expected parse("B*44:327") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:327") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_328N():
    result = parse("B*44:328N")
    assert result.__class__ is Allele, f'Expected parse("B*44:328N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:328N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_329():
    result = parse("B*44:329")
    assert result.__class__ is Allele, f'Expected parse("B*44:329") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:329") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_33():
    result = parse("B*44:33")
    assert result.__class__ is Allele, f'Expected parse("B*44:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_330():
    result = parse("B*44:330")
    assert result.__class__ is Allele, f'Expected parse("B*44:330") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:330") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_331():
    result = parse("B*44:331")
    assert result.__class__ is Allele, f'Expected parse("B*44:331") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:331") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_332():
    result = parse("B*44:332")
    assert result.__class__ is Allele, f'Expected parse("B*44:332") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:332") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_333N():
    result = parse("B*44:333N")
    assert result.__class__ is Allele, f'Expected parse("B*44:333N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:333N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_334N():
    result = parse("B*44:334N")
    assert result.__class__ is Allele, f'Expected parse("B*44:334N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:334N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_335():
    result = parse("B*44:335")
    assert result.__class__ is Allele, f'Expected parse("B*44:335") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:335") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_336():
    result = parse("B*44:336")
    assert result.__class__ is Allele, f'Expected parse("B*44:336") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:336") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_337():
    result = parse("B*44:337")
    assert result.__class__ is Allele, f'Expected parse("B*44:337") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:337") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_338():
    result = parse("B*44:338")
    assert result.__class__ is Allele, f'Expected parse("B*44:338") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:338") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_339():
    result = parse("B*44:339")
    assert result.__class__ is Allele, f'Expected parse("B*44:339") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:339") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_340():
    result = parse("B*44:340")
    assert result.__class__ is Allele, f'Expected parse("B*44:340") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:340") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_341N():
    result = parse("B*44:341N")
    assert result.__class__ is Allele, f'Expected parse("B*44:341N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:341N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_342():
    result = parse("B*44:342")
    assert result.__class__ is Allele, f'Expected parse("B*44:342") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:342") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_343():
    result = parse("B*44:343")
    assert result.__class__ is Allele, f'Expected parse("B*44:343") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:343") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_344():
    result = parse("B*44:344")
    assert result.__class__ is Allele, f'Expected parse("B*44:344") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:344") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_345N():
    result = parse("B*44:345N")
    assert result.__class__ is Allele, f'Expected parse("B*44:345N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:345N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_346():
    result = parse("B*44:346")
    assert result.__class__ is Allele, f'Expected parse("B*44:346") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:346") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_34_01():
    result = parse("B*44:34:01")
    assert result.__class__ is Allele, f'Expected parse("B*44:34:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:34:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_34_02():
    result = parse("B*44:34:02")
    assert result.__class__ is Allele, f'Expected parse("B*44:34:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:34:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_35():
    result = parse("B*44:35")
    assert result.__class__ is Allele, f'Expected parse("B*44:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_36():
    result = parse("B*44:36")
    assert result.__class__ is Allele, f'Expected parse("B*44:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_37_01():
    result = parse("B*44:37:01")
    assert result.__class__ is Allele, f'Expected parse("B*44:37:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:37:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_37_02():
    result = parse("B*44:37:02")
    assert result.__class__ is Allele, f'Expected parse("B*44:37:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:37:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_38():
    result = parse("B*44:38")
    assert result.__class__ is Allele, f'Expected parse("B*44:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_39():
    result = parse("B*44:39")
    assert result.__class__ is Allele, f'Expected parse("B*44:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_40():
    result = parse("B*44:40")
    assert result.__class__ is Allele, f'Expected parse("B*44:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_41_01():
    result = parse("B*44:41:01")
    assert result.__class__ is Allele, f'Expected parse("B*44:41:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:41:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_41_02():
    result = parse("B*44:41:02")
    assert result.__class__ is Allele, f'Expected parse("B*44:41:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:41:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_42():
    result = parse("B*44:42")
    assert result.__class__ is Allele, f'Expected parse("B*44:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_437():
    result = parse("B*44:437")
    assert result.__class__ is Allele, f'Expected parse("B*44:437") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:437") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_438N():
    result = parse("B*44:438N")
    assert result.__class__ is Allele, f'Expected parse("B*44:438N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:438N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_439():
    result = parse("B*44:439")
    assert result.__class__ is Allele, f'Expected parse("B*44:439") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:439") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_43_01():
    result = parse("B*44:43:01")
    assert result.__class__ is Allele, f'Expected parse("B*44:43:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:43:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_43_02():
    result = parse("B*44:43:02")
    assert result.__class__ is Allele, f'Expected parse("B*44:43:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:43:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_44():
    result = parse("B*44:44")
    assert result.__class__ is Allele, f'Expected parse("B*44:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_440():
    result = parse("B*44:440")
    assert result.__class__ is Allele, f'Expected parse("B*44:440") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:440") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_441():
    result = parse("B*44:441")
    assert result.__class__ is Allele, f'Expected parse("B*44:441") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:441") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_442():
    result = parse("B*44:442")
    assert result.__class__ is Allele, f'Expected parse("B*44:442") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:442") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_443():
    result = parse("B*44:443")
    assert result.__class__ is Allele, f'Expected parse("B*44:443") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:443") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_444():
    result = parse("B*44:444")
    assert result.__class__ is Allele, f'Expected parse("B*44:444") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:444") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_445():
    result = parse("B*44:445")
    assert result.__class__ is Allele, f'Expected parse("B*44:445") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:445") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_446():
    result = parse("B*44:446")
    assert result.__class__ is Allele, f'Expected parse("B*44:446") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:446") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_447():
    result = parse("B*44:447")
    assert result.__class__ is Allele, f'Expected parse("B*44:447") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:447") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_448N():
    result = parse("B*44:448N")
    assert result.__class__ is Allele, f'Expected parse("B*44:448N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:448N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_449N():
    result = parse("B*44:449N")
    assert result.__class__ is Allele, f'Expected parse("B*44:449N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:449N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_45():
    result = parse("B*44:45")
    assert result.__class__ is Allele, f'Expected parse("B*44:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_450():
    result = parse("B*44:450")
    assert result.__class__ is Allele, f'Expected parse("B*44:450") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:450") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_451():
    result = parse("B*44:451")
    assert result.__class__ is Allele, f'Expected parse("B*44:451") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:451") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_452():
    result = parse("B*44:452")
    assert result.__class__ is Allele, f'Expected parse("B*44:452") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:452") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_453():
    result = parse("B*44:453")
    assert result.__class__ is Allele, f'Expected parse("B*44:453") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:453") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_454():
    result = parse("B*44:454")
    assert result.__class__ is Allele, f'Expected parse("B*44:454") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:454") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_455():
    result = parse("B*44:455")
    assert result.__class__ is Allele, f'Expected parse("B*44:455") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:455") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_456():
    result = parse("B*44:456")
    assert result.__class__ is Allele, f'Expected parse("B*44:456") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:456") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_457():
    result = parse("B*44:457")
    assert result.__class__ is Allele, f'Expected parse("B*44:457") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:457") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_458():
    result = parse("B*44:458")
    assert result.__class__ is Allele, f'Expected parse("B*44:458") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:458") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_459():
    result = parse("B*44:459")
    assert result.__class__ is Allele, f'Expected parse("B*44:459") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:459") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_460():
    result = parse("B*44:460")
    assert result.__class__ is Allele, f'Expected parse("B*44:460") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:460") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_461():
    result = parse("B*44:461")
    assert result.__class__ is Allele, f'Expected parse("B*44:461") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:461") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_462():
    result = parse("B*44:462")
    assert result.__class__ is Allele, f'Expected parse("B*44:462") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:462") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_463():
    result = parse("B*44:463")
    assert result.__class__ is Allele, f'Expected parse("B*44:463") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:463") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_464_01_01():
    result = parse("B*44:464:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:464:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:464:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_464_01_02():
    result = parse("B*44:464:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*44:464:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*44:464:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_465():
    result = parse("B*44:465")
    assert result.__class__ is Allele, f'Expected parse("B*44:465") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:465") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_467():
    result = parse("B*44:467")
    assert result.__class__ is Allele, f'Expected parse("B*44:467") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:467") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_468():
    result = parse("B*44:468")
    assert result.__class__ is Allele, f'Expected parse("B*44:468") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:468") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_469():
    result = parse("B*44:469")
    assert result.__class__ is Allele, f'Expected parse("B*44:469") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:469") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_46_01():
    result = parse("B*44:46:01")
    assert result.__class__ is Allele, f'Expected parse("B*44:46:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:46:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_46_02():
    result = parse("B*44:46:02")
    assert result.__class__ is Allele, f'Expected parse("B*44:46:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:46:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_47():
    result = parse("B*44:47")
    assert result.__class__ is Allele, f'Expected parse("B*44:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_470():
    result = parse("B*44:470")
    assert result.__class__ is Allele, f'Expected parse("B*44:470") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:470") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_471():
    result = parse("B*44:471")
    assert result.__class__ is Allele, f'Expected parse("B*44:471") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:471") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_472():
    result = parse("B*44:472")
    assert result.__class__ is Allele, f'Expected parse("B*44:472") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:472") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_473():
    result = parse("B*44:473")
    assert result.__class__ is Allele, f'Expected parse("B*44:473") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:473") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_474():
    result = parse("B*44:474")
    assert result.__class__ is Allele, f'Expected parse("B*44:474") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:474") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_475():
    result = parse("B*44:475")
    assert result.__class__ is Allele, f'Expected parse("B*44:475") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:475") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_476():
    result = parse("B*44:476")
    assert result.__class__ is Allele, f'Expected parse("B*44:476") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:476") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_477():
    result = parse("B*44:477")
    assert result.__class__ is Allele, f'Expected parse("B*44:477") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:477") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_478():
    result = parse("B*44:478")
    assert result.__class__ is Allele, f'Expected parse("B*44:478") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:478") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_479():
    result = parse("B*44:479")
    assert result.__class__ is Allele, f'Expected parse("B*44:479") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:479") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_48():
    result = parse("B*44:48")
    assert result.__class__ is Allele, f'Expected parse("B*44:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_480Q():
    result = parse("B*44:480Q")
    assert result.__class__ is Allele, f'Expected parse("B*44:480Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:480Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_481():
    result = parse("B*44:481")
    assert result.__class__ is Allele, f'Expected parse("B*44:481") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:481") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_482():
    result = parse("B*44:482")
    assert result.__class__ is Allele, f'Expected parse("B*44:482") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:482") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_483():
    result = parse("B*44:483")
    assert result.__class__ is Allele, f'Expected parse("B*44:483") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:483") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_484():
    result = parse("B*44:484")
    assert result.__class__ is Allele, f'Expected parse("B*44:484") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:484") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_485():
    result = parse("B*44:485")
    assert result.__class__ is Allele, f'Expected parse("B*44:485") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:485") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_486():
    result = parse("B*44:486")
    assert result.__class__ is Allele, f'Expected parse("B*44:486") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:486") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_487():
    result = parse("B*44:487")
    assert result.__class__ is Allele, f'Expected parse("B*44:487") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:487") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_488():
    result = parse("B*44:488")
    assert result.__class__ is Allele, f'Expected parse("B*44:488") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:488") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_489():
    result = parse("B*44:489")
    assert result.__class__ is Allele, f'Expected parse("B*44:489") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:489") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_49():
    result = parse("B*44:49")
    assert result.__class__ is Allele, f'Expected parse("B*44:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_490():
    result = parse("B*44:490")
    assert result.__class__ is Allele, f'Expected parse("B*44:490") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:490") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_491():
    result = parse("B*44:491")
    assert result.__class__ is Allele, f'Expected parse("B*44:491") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:491") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_492():
    result = parse("B*44:492")
    assert result.__class__ is Allele, f'Expected parse("B*44:492") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:492") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_50_01():
    result = parse("B*44:50:01")
    assert result.__class__ is Allele, f'Expected parse("B*44:50:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:50:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_50_02():
    result = parse("B*44:50:02")
    assert result.__class__ is Allele, f'Expected parse("B*44:50:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:50:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_50_03():
    result = parse("B*44:50:03")
    assert result.__class__ is Allele, f'Expected parse("B*44:50:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:50:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_51():
    result = parse("B*44:51")
    assert result.__class__ is Allele, f'Expected parse("B*44:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_52N():
    result = parse("B*44:52N")
    assert result.__class__ is Allele, f'Expected parse("B*44:52N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:52N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_53_01():
    result = parse("B*44:53:01")
    assert result.__class__ is Allele, f'Expected parse("B*44:53:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:53:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_53_02():
    result = parse("B*44:53:02")
    assert result.__class__ is Allele, f'Expected parse("B*44:53:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:53:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_54():
    result = parse("B*44:54")
    assert result.__class__ is Allele, f'Expected parse("B*44:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_55():
    result = parse("B*44:55")
    assert result.__class__ is Allele, f'Expected parse("B*44:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_56N():
    result = parse("B*44:56N")
    assert result.__class__ is Allele, f'Expected parse("B*44:56N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:56N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_57():
    result = parse("B*44:57")
    assert result.__class__ is Allele, f'Expected parse("B*44:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_58N():
    result = parse("B*44:58N")
    assert result.__class__ is Allele, f'Expected parse("B*44:58N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:58N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_59_01():
    result = parse("B*44:59:01")
    assert result.__class__ is Allele, f'Expected parse("B*44:59:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:59:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_59_02():
    result = parse("B*44:59:02")
    assert result.__class__ is Allele, f'Expected parse("B*44:59:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:59:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_60():
    result = parse("B*44:60")
    assert result.__class__ is Allele, f'Expected parse("B*44:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_61N():
    result = parse("B*44:61N")
    assert result.__class__ is Allele, f'Expected parse("B*44:61N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:61N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_62():
    result = parse("B*44:62")
    assert result.__class__ is Allele, f'Expected parse("B*44:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_63():
    result = parse("B*44:63")
    assert result.__class__ is Allele, f'Expected parse("B*44:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_64_01():
    result = parse("B*44:64:01")
    assert result.__class__ is Allele, f'Expected parse("B*44:64:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:64:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_64_02():
    result = parse("B*44:64:02")
    assert result.__class__ is Allele, f'Expected parse("B*44:64:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:64:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_65():
    result = parse("B*44:65")
    assert result.__class__ is Allele, f'Expected parse("B*44:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_66():
    result = parse("B*44:66")
    assert result.__class__ is Allele, f'Expected parse("B*44:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_67():
    result = parse("B*44:67")
    assert result.__class__ is Allele, f'Expected parse("B*44:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_68():
    result = parse("B*44:68")
    assert result.__class__ is Allele, f'Expected parse("B*44:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_69_01():
    result = parse("B*44:69:01")
    assert result.__class__ is Allele, f'Expected parse("B*44:69:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:69:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_69_02():
    result = parse("B*44:69:02")
    assert result.__class__ is Allele, f'Expected parse("B*44:69:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:69:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_70():
    result = parse("B*44:70")
    assert result.__class__ is Allele, f'Expected parse("B*44:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_71():
    result = parse("B*44:71")
    assert result.__class__ is Allele, f'Expected parse("B*44:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_72():
    result = parse("B*44:72")
    assert result.__class__ is Allele, f'Expected parse("B*44:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_73():
    result = parse("B*44:73")
    assert result.__class__ is Allele, f'Expected parse("B*44:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_74():
    result = parse("B*44:74")
    assert result.__class__ is Allele, f'Expected parse("B*44:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_75():
    result = parse("B*44:75")
    assert result.__class__ is Allele, f'Expected parse("B*44:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_76():
    result = parse("B*44:76")
    assert result.__class__ is Allele, f'Expected parse("B*44:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_77():
    result = parse("B*44:77")
    assert result.__class__ is Allele, f'Expected parse("B*44:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_78():
    result = parse("B*44:78")
    assert result.__class__ is Allele, f'Expected parse("B*44:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_79_01():
    result = parse("B*44:79:01")
    assert result.__class__ is Allele, f'Expected parse("B*44:79:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:79:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_79_02():
    result = parse("B*44:79:02")
    assert result.__class__ is Allele, f'Expected parse("B*44:79:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:79:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_80():
    result = parse("B*44:80")
    assert result.__class__ is Allele, f'Expected parse("B*44:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_81():
    result = parse("B*44:81")
    assert result.__class__ is Allele, f'Expected parse("B*44:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_82():
    result = parse("B*44:82")
    assert result.__class__ is Allele, f'Expected parse("B*44:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_83():
    result = parse("B*44:83")
    assert result.__class__ is Allele, f'Expected parse("B*44:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_84_01():
    result = parse("B*44:84:01")
    assert result.__class__ is Allele, f'Expected parse("B*44:84:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:84:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_84_02():
    result = parse("B*44:84:02")
    assert result.__class__ is Allele, f'Expected parse("B*44:84:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*44:84:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_85():
    result = parse("B*44:85")
    assert result.__class__ is Allele, f'Expected parse("B*44:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_86():
    result = parse("B*44:86")
    assert result.__class__ is Allele, f'Expected parse("B*44:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_87():
    result = parse("B*44:87")
    assert result.__class__ is Allele, f'Expected parse("B*44:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_88():
    result = parse("B*44:88")
    assert result.__class__ is Allele, f'Expected parse("B*44:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_89():
    result = parse("B*44:89")
    assert result.__class__ is Allele, f'Expected parse("B*44:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_90():
    result = parse("B*44:90")
    assert result.__class__ is Allele, f'Expected parse("B*44:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_91():
    result = parse("B*44:91")
    assert result.__class__ is Allele, f'Expected parse("B*44:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_92():
    result = parse("B*44:92")
    assert result.__class__ is Allele, f'Expected parse("B*44:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_93():
    result = parse("B*44:93")
    assert result.__class__ is Allele, f'Expected parse("B*44:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_94():
    result = parse("B*44:94")
    assert result.__class__ is Allele, f'Expected parse("B*44:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_95():
    result = parse("B*44:95")
    assert result.__class__ is Allele, f'Expected parse("B*44:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_96():
    result = parse("B*44:96")
    assert result.__class__ is Allele, f'Expected parse("B*44:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_97():
    result = parse("B*44:97")
    assert result.__class__ is Allele, f'Expected parse("B*44:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_98():
    result = parse("B*44:98")
    assert result.__class__ is Allele, f'Expected parse("B*44:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_44_99():
    result = parse("B*44:99")
    assert result.__class__ is Allele, f'Expected parse("B*44:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*44:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_01_01_01():
    result = parse("B*45:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*45:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*45:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_01_01_02():
    result = parse("B*45:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*45:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*45:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_01_01_03():
    result = parse("B*45:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*45:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*45:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_01_01_04():
    result = parse("B*45:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*45:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*45:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_01_01_05():
    result = parse("B*45:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*45:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*45:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_01_01_06():
    result = parse("B*45:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*45:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*45:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_01_01_07():
    result = parse("B*45:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*45:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*45:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_01_02():
    result = parse("B*45:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*45:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*45:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_01_03():
    result = parse("B*45:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*45:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*45:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_01_04():
    result = parse("B*45:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*45:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*45:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_01_05():
    result = parse("B*45:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*45:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*45:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_01_06():
    result = parse("B*45:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*45:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*45:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_01_07():
    result = parse("B*45:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*45:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*45:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_01_08():
    result = parse("B*45:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*45:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*45:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_01_09():
    result = parse("B*45:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*45:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*45:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_01_10():
    result = parse("B*45:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*45:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*45:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_02():
    result = parse("B*45:02")
    assert result.__class__ is Allele, f'Expected parse("B*45:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_03():
    result = parse("B*45:03")
    assert result.__class__ is Allele, f'Expected parse("B*45:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_04():
    result = parse("B*45:04")
    assert result.__class__ is Allele, f'Expected parse("B*45:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_05():
    result = parse("B*45:05")
    assert result.__class__ is Allele, f'Expected parse("B*45:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_06():
    result = parse("B*45:06")
    assert result.__class__ is Allele, f'Expected parse("B*45:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_07():
    result = parse("B*45:07")
    assert result.__class__ is Allele, f'Expected parse("B*45:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_08():
    result = parse("B*45:08")
    assert result.__class__ is Allele, f'Expected parse("B*45:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_09():
    result = parse("B*45:09")
    assert result.__class__ is Allele, f'Expected parse("B*45:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_10():
    result = parse("B*45:10")
    assert result.__class__ is Allele, f'Expected parse("B*45:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_11():
    result = parse("B*45:11")
    assert result.__class__ is Allele, f'Expected parse("B*45:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_12():
    result = parse("B*45:12")
    assert result.__class__ is Allele, f'Expected parse("B*45:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_13():
    result = parse("B*45:13")
    assert result.__class__ is Allele, f'Expected parse("B*45:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_14():
    result = parse("B*45:14")
    assert result.__class__ is Allele, f'Expected parse("B*45:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_15():
    result = parse("B*45:15")
    assert result.__class__ is Allele, f'Expected parse("B*45:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_16():
    result = parse("B*45:16")
    assert result.__class__ is Allele, f'Expected parse("B*45:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_17():
    result = parse("B*45:17")
    assert result.__class__ is Allele, f'Expected parse("B*45:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_18():
    result = parse("B*45:18")
    assert result.__class__ is Allele, f'Expected parse("B*45:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_19():
    result = parse("B*45:19")
    assert result.__class__ is Allele, f'Expected parse("B*45:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_20():
    result = parse("B*45:20")
    assert result.__class__ is Allele, f'Expected parse("B*45:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_21():
    result = parse("B*45:21")
    assert result.__class__ is Allele, f'Expected parse("B*45:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_22():
    result = parse("B*45:22")
    assert result.__class__ is Allele, f'Expected parse("B*45:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_23():
    result = parse("B*45:23")
    assert result.__class__ is Allele, f'Expected parse("B*45:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_24():
    result = parse("B*45:24")
    assert result.__class__ is Allele, f'Expected parse("B*45:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_45_25():
    result = parse("B*45:25")
    assert result.__class__ is Allele, f'Expected parse("B*45:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*45:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_01_01():
    result = parse("B*46:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*46:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*46:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_01_02():
    result = parse("B*46:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*46:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*46:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_01_03():
    result = parse("B*46:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*46:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*46:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_01_04():
    result = parse("B*46:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*46:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*46:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_02():
    result = parse("B*46:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_03():
    result = parse("B*46:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_04():
    result = parse("B*46:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_05():
    result = parse("B*46:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_06():
    result = parse("B*46:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_07():
    result = parse("B*46:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_08():
    result = parse("B*46:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_09():
    result = parse("B*46:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_10():
    result = parse("B*46:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_11():
    result = parse("B*46:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_12():
    result = parse("B*46:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_13():
    result = parse("B*46:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_14():
    result = parse("B*46:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_15():
    result = parse("B*46:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_16():
    result = parse("B*46:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_17():
    result = parse("B*46:01:17")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_18():
    result = parse("B*46:01:18")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_19():
    result = parse("B*46:01:19")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_20():
    result = parse("B*46:01:20")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_21():
    result = parse("B*46:01:21")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_22():
    result = parse("B*46:01:22")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_23():
    result = parse("B*46:01:23")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_24():
    result = parse("B*46:01:24")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_25():
    result = parse("B*46:01:25")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_26():
    result = parse("B*46:01:26")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_27():
    result = parse("B*46:01:27")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_28():
    result = parse("B*46:01:28")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_01_29():
    result = parse("B*46:01:29")
    assert result.__class__ is Allele, f'Expected parse("B*46:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_02():
    result = parse("B*46:02")
    assert result.__class__ is Allele, f'Expected parse("B*46:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_03():
    result = parse("B*46:03")
    assert result.__class__ is Allele, f'Expected parse("B*46:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_04():
    result = parse("B*46:04")
    assert result.__class__ is Allele, f'Expected parse("B*46:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_05():
    result = parse("B*46:05")
    assert result.__class__ is Allele, f'Expected parse("B*46:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_06():
    result = parse("B*46:06")
    assert result.__class__ is Allele, f'Expected parse("B*46:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_07N():
    result = parse("B*46:07N")
    assert result.__class__ is Allele, f'Expected parse("B*46:07N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:07N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_08():
    result = parse("B*46:08")
    assert result.__class__ is Allele, f'Expected parse("B*46:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_09():
    result = parse("B*46:09")
    assert result.__class__ is Allele, f'Expected parse("B*46:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_10():
    result = parse("B*46:10")
    assert result.__class__ is Allele, f'Expected parse("B*46:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_11():
    result = parse("B*46:11")
    assert result.__class__ is Allele, f'Expected parse("B*46:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_12():
    result = parse("B*46:12")
    assert result.__class__ is Allele, f'Expected parse("B*46:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_13_01():
    result = parse("B*46:13:01")
    assert result.__class__ is Allele, f'Expected parse("B*46:13:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:13:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_13_02():
    result = parse("B*46:13:02")
    assert result.__class__ is Allele, f'Expected parse("B*46:13:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:13:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_13_03():
    result = parse("B*46:13:03")
    assert result.__class__ is Allele, f'Expected parse("B*46:13:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:13:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_14():
    result = parse("B*46:14")
    assert result.__class__ is Allele, f'Expected parse("B*46:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_15N():
    result = parse("B*46:15N")
    assert result.__class__ is Allele, f'Expected parse("B*46:15N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:15N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_16():
    result = parse("B*46:16")
    assert result.__class__ is Allele, f'Expected parse("B*46:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_17():
    result = parse("B*46:17")
    assert result.__class__ is Allele, f'Expected parse("B*46:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_18():
    result = parse("B*46:18")
    assert result.__class__ is Allele, f'Expected parse("B*46:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_19():
    result = parse("B*46:19")
    assert result.__class__ is Allele, f'Expected parse("B*46:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_20():
    result = parse("B*46:20")
    assert result.__class__ is Allele, f'Expected parse("B*46:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_21_01():
    result = parse("B*46:21:01")
    assert result.__class__ is Allele, f'Expected parse("B*46:21:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:21:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_21_02():
    result = parse("B*46:21:02")
    assert result.__class__ is Allele, f'Expected parse("B*46:21:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:21:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_22():
    result = parse("B*46:22")
    assert result.__class__ is Allele, f'Expected parse("B*46:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_23():
    result = parse("B*46:23")
    assert result.__class__ is Allele, f'Expected parse("B*46:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_24():
    result = parse("B*46:24")
    assert result.__class__ is Allele, f'Expected parse("B*46:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_25():
    result = parse("B*46:25")
    assert result.__class__ is Allele, f'Expected parse("B*46:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_26():
    result = parse("B*46:26")
    assert result.__class__ is Allele, f'Expected parse("B*46:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_27():
    result = parse("B*46:27")
    assert result.__class__ is Allele, f'Expected parse("B*46:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_28():
    result = parse("B*46:28")
    assert result.__class__ is Allele, f'Expected parse("B*46:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_29():
    result = parse("B*46:29")
    assert result.__class__ is Allele, f'Expected parse("B*46:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_30():
    result = parse("B*46:30")
    assert result.__class__ is Allele, f'Expected parse("B*46:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_31():
    result = parse("B*46:31")
    assert result.__class__ is Allele, f'Expected parse("B*46:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_32_01():
    result = parse("B*46:32:01")
    assert result.__class__ is Allele, f'Expected parse("B*46:32:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:32:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_32_02():
    result = parse("B*46:32:02")
    assert result.__class__ is Allele, f'Expected parse("B*46:32:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:32:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_33():
    result = parse("B*46:33")
    assert result.__class__ is Allele, f'Expected parse("B*46:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_34():
    result = parse("B*46:34")
    assert result.__class__ is Allele, f'Expected parse("B*46:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_35():
    result = parse("B*46:35")
    assert result.__class__ is Allele, f'Expected parse("B*46:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_36():
    result = parse("B*46:36")
    assert result.__class__ is Allele, f'Expected parse("B*46:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_37():
    result = parse("B*46:37")
    assert result.__class__ is Allele, f'Expected parse("B*46:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_38():
    result = parse("B*46:38")
    assert result.__class__ is Allele, f'Expected parse("B*46:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_39():
    result = parse("B*46:39")
    assert result.__class__ is Allele, f'Expected parse("B*46:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_40_01():
    result = parse("B*46:40:01")
    assert result.__class__ is Allele, f'Expected parse("B*46:40:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:40:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_40_02():
    result = parse("B*46:40:02")
    assert result.__class__ is Allele, f'Expected parse("B*46:40:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*46:40:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_41N():
    result = parse("B*46:41N")
    assert result.__class__ is Allele, f'Expected parse("B*46:41N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:41N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_42():
    result = parse("B*46:42")
    assert result.__class__ is Allele, f'Expected parse("B*46:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_43():
    result = parse("B*46:43")
    assert result.__class__ is Allele, f'Expected parse("B*46:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_44():
    result = parse("B*46:44")
    assert result.__class__ is Allele, f'Expected parse("B*46:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_45():
    result = parse("B*46:45")
    assert result.__class__ is Allele, f'Expected parse("B*46:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_46():
    result = parse("B*46:46")
    assert result.__class__ is Allele, f'Expected parse("B*46:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_47():
    result = parse("B*46:47")
    assert result.__class__ is Allele, f'Expected parse("B*46:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_48():
    result = parse("B*46:48")
    assert result.__class__ is Allele, f'Expected parse("B*46:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_49():
    result = parse("B*46:49")
    assert result.__class__ is Allele, f'Expected parse("B*46:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_50():
    result = parse("B*46:50")
    assert result.__class__ is Allele, f'Expected parse("B*46:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_51Q():
    result = parse("B*46:51Q")
    assert result.__class__ is Allele, f'Expected parse("B*46:51Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:51Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_52():
    result = parse("B*46:52")
    assert result.__class__ is Allele, f'Expected parse("B*46:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_53():
    result = parse("B*46:53")
    assert result.__class__ is Allele, f'Expected parse("B*46:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_54():
    result = parse("B*46:54")
    assert result.__class__ is Allele, f'Expected parse("B*46:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_55N():
    result = parse("B*46:55N")
    assert result.__class__ is Allele, f'Expected parse("B*46:55N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:55N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_56():
    result = parse("B*46:56")
    assert result.__class__ is Allele, f'Expected parse("B*46:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_57():
    result = parse("B*46:57")
    assert result.__class__ is Allele, f'Expected parse("B*46:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_58():
    result = parse("B*46:58")
    assert result.__class__ is Allele, f'Expected parse("B*46:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_59():
    result = parse("B*46:59")
    assert result.__class__ is Allele, f'Expected parse("B*46:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_60():
    result = parse("B*46:60")
    assert result.__class__ is Allele, f'Expected parse("B*46:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_61():
    result = parse("B*46:61")
    assert result.__class__ is Allele, f'Expected parse("B*46:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_62():
    result = parse("B*46:62")
    assert result.__class__ is Allele, f'Expected parse("B*46:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_63():
    result = parse("B*46:63")
    assert result.__class__ is Allele, f'Expected parse("B*46:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_64():
    result = parse("B*46:64")
    assert result.__class__ is Allele, f'Expected parse("B*46:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_65():
    result = parse("B*46:65")
    assert result.__class__ is Allele, f'Expected parse("B*46:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_66():
    result = parse("B*46:66")
    assert result.__class__ is Allele, f'Expected parse("B*46:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_67():
    result = parse("B*46:67")
    assert result.__class__ is Allele, f'Expected parse("B*46:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_68():
    result = parse("B*46:68")
    assert result.__class__ is Allele, f'Expected parse("B*46:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_69():
    result = parse("B*46:69")
    assert result.__class__ is Allele, f'Expected parse("B*46:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_70():
    result = parse("B*46:70")
    assert result.__class__ is Allele, f'Expected parse("B*46:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_71():
    result = parse("B*46:71")
    assert result.__class__ is Allele, f'Expected parse("B*46:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_72():
    result = parse("B*46:72")
    assert result.__class__ is Allele, f'Expected parse("B*46:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_73():
    result = parse("B*46:73")
    assert result.__class__ is Allele, f'Expected parse("B*46:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_74():
    result = parse("B*46:74")
    assert result.__class__ is Allele, f'Expected parse("B*46:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_75():
    result = parse("B*46:75")
    assert result.__class__ is Allele, f'Expected parse("B*46:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_76():
    result = parse("B*46:76")
    assert result.__class__ is Allele, f'Expected parse("B*46:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_77():
    result = parse("B*46:77")
    assert result.__class__ is Allele, f'Expected parse("B*46:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_78():
    result = parse("B*46:78")
    assert result.__class__ is Allele, f'Expected parse("B*46:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_79N():
    result = parse("B*46:79N")
    assert result.__class__ is Allele, f'Expected parse("B*46:79N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:79N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_80():
    result = parse("B*46:80")
    assert result.__class__ is Allele, f'Expected parse("B*46:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_46_81():
    result = parse("B*46:81")
    assert result.__class__ is Allele, f'Expected parse("B*46:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*46:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_01_01_02():
    result = parse("B*47:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*47:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*47:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_01_01_03():
    result = parse("B*47:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*47:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*47:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_01_01_04():
    result = parse("B*47:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*47:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*47:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_01_01_05():
    result = parse("B*47:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*47:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*47:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_01_01_06():
    result = parse("B*47:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*47:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*47:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_01_02():
    result = parse("B*47:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*47:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*47:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_01_03():
    result = parse("B*47:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*47:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*47:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_01_04():
    result = parse("B*47:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*47:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*47:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_01_05():
    result = parse("B*47:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*47:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*47:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_02():
    result = parse("B*47:02")
    assert result.__class__ is Allele, f'Expected parse("B*47:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*47:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_03():
    result = parse("B*47:03")
    assert result.__class__ is Allele, f'Expected parse("B*47:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*47:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_04():
    result = parse("B*47:04")
    assert result.__class__ is Allele, f'Expected parse("B*47:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*47:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_05():
    result = parse("B*47:05")
    assert result.__class__ is Allele, f'Expected parse("B*47:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*47:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_06():
    result = parse("B*47:06")
    assert result.__class__ is Allele, f'Expected parse("B*47:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*47:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_07():
    result = parse("B*47:07")
    assert result.__class__ is Allele, f'Expected parse("B*47:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*47:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_08():
    result = parse("B*47:08")
    assert result.__class__ is Allele, f'Expected parse("B*47:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*47:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_09():
    result = parse("B*47:09")
    assert result.__class__ is Allele, f'Expected parse("B*47:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*47:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_47_10():
    result = parse("B*47:10")
    assert result.__class__ is Allele, f'Expected parse("B*47:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*47:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_01_01_01():
    result = parse("B*48:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*48:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*48:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_01_01_02():
    result = parse("B*48:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*48:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*48:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_01_01_03():
    result = parse("B*48:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*48:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*48:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_01_01_04():
    result = parse("B*48:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*48:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*48:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_01_01_05():
    result = parse("B*48:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*48:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*48:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_01_01_06():
    result = parse("B*48:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*48:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*48:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_01_01_07():
    result = parse("B*48:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*48:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*48:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_01_02():
    result = parse("B*48:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*48:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*48:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_01_03():
    result = parse("B*48:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*48:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*48:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_01_04():
    result = parse("B*48:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*48:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*48:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_01_05():
    result = parse("B*48:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*48:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*48:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_01_06():
    result = parse("B*48:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*48:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*48:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_01_07():
    result = parse("B*48:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*48:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*48:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_01_08():
    result = parse("B*48:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*48:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*48:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_01_09():
    result = parse("B*48:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*48:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*48:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_01_10():
    result = parse("B*48:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*48:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*48:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_02_01():
    result = parse("B*48:02:01")
    assert result.__class__ is Allele, f'Expected parse("B*48:02:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*48:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_02_02():
    result = parse("B*48:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*48:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*48:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_02_03():
    result = parse("B*48:02:03")
    assert result.__class__ is Allele, f'Expected parse("B*48:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*48:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_03_01_01():
    result = parse("B*48:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*48:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*48:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_03_01_02():
    result = parse("B*48:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*48:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*48:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_03_01_03():
    result = parse("B*48:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*48:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*48:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_03_02():
    result = parse("B*48:03:02")
    assert result.__class__ is Allele, f'Expected parse("B*48:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*48:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_04_01_01():
    result = parse("B*48:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*48:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*48:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_04_01_02():
    result = parse("B*48:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*48:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*48:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_04_02():
    result = parse("B*48:04:02")
    assert result.__class__ is Allele, f'Expected parse("B*48:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*48:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_05():
    result = parse("B*48:05")
    assert result.__class__ is Allele, f'Expected parse("B*48:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_06():
    result = parse("B*48:06")
    assert result.__class__ is Allele, f'Expected parse("B*48:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_07():
    result = parse("B*48:07")
    assert result.__class__ is Allele, f'Expected parse("B*48:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_08():
    result = parse("B*48:08")
    assert result.__class__ is Allele, f'Expected parse("B*48:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_09():
    result = parse("B*48:09")
    assert result.__class__ is Allele, f'Expected parse("B*48:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_10():
    result = parse("B*48:10")
    assert result.__class__ is Allele, f'Expected parse("B*48:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_11():
    result = parse("B*48:11")
    assert result.__class__ is Allele, f'Expected parse("B*48:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_12():
    result = parse("B*48:12")
    assert result.__class__ is Allele, f'Expected parse("B*48:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_13():
    result = parse("B*48:13")
    assert result.__class__ is Allele, f'Expected parse("B*48:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_14():
    result = parse("B*48:14")
    assert result.__class__ is Allele, f'Expected parse("B*48:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_15():
    result = parse("B*48:15")
    assert result.__class__ is Allele, f'Expected parse("B*48:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_16():
    result = parse("B*48:16")
    assert result.__class__ is Allele, f'Expected parse("B*48:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_17():
    result = parse("B*48:17")
    assert result.__class__ is Allele, f'Expected parse("B*48:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_18():
    result = parse("B*48:18")
    assert result.__class__ is Allele, f'Expected parse("B*48:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_19():
    result = parse("B*48:19")
    assert result.__class__ is Allele, f'Expected parse("B*48:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_20():
    result = parse("B*48:20")
    assert result.__class__ is Allele, f'Expected parse("B*48:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_21():
    result = parse("B*48:21")
    assert result.__class__ is Allele, f'Expected parse("B*48:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_22():
    result = parse("B*48:22")
    assert result.__class__ is Allele, f'Expected parse("B*48:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_23():
    result = parse("B*48:23")
    assert result.__class__ is Allele, f'Expected parse("B*48:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_24():
    result = parse("B*48:24")
    assert result.__class__ is Allele, f'Expected parse("B*48:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_25():
    result = parse("B*48:25")
    assert result.__class__ is Allele, f'Expected parse("B*48:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_26():
    result = parse("B*48:26")
    assert result.__class__ is Allele, f'Expected parse("B*48:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_27():
    result = parse("B*48:27")
    assert result.__class__ is Allele, f'Expected parse("B*48:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_28():
    result = parse("B*48:28")
    assert result.__class__ is Allele, f'Expected parse("B*48:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_29():
    result = parse("B*48:29")
    assert result.__class__ is Allele, f'Expected parse("B*48:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_30():
    result = parse("B*48:30")
    assert result.__class__ is Allele, f'Expected parse("B*48:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_31():
    result = parse("B*48:31")
    assert result.__class__ is Allele, f'Expected parse("B*48:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_32():
    result = parse("B*48:32")
    assert result.__class__ is Allele, f'Expected parse("B*48:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_33():
    result = parse("B*48:33")
    assert result.__class__ is Allele, f'Expected parse("B*48:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_34():
    result = parse("B*48:34")
    assert result.__class__ is Allele, f'Expected parse("B*48:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_35():
    result = parse("B*48:35")
    assert result.__class__ is Allele, f'Expected parse("B*48:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_36():
    result = parse("B*48:36")
    assert result.__class__ is Allele, f'Expected parse("B*48:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_37():
    result = parse("B*48:37")
    assert result.__class__ is Allele, f'Expected parse("B*48:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_38():
    result = parse("B*48:38")
    assert result.__class__ is Allele, f'Expected parse("B*48:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_39():
    result = parse("B*48:39")
    assert result.__class__ is Allele, f'Expected parse("B*48:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_40():
    result = parse("B*48:40")
    assert result.__class__ is Allele, f'Expected parse("B*48:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_41():
    result = parse("B*48:41")
    assert result.__class__ is Allele, f'Expected parse("B*48:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_42():
    result = parse("B*48:42")
    assert result.__class__ is Allele, f'Expected parse("B*48:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_43():
    result = parse("B*48:43")
    assert result.__class__ is Allele, f'Expected parse("B*48:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_44():
    result = parse("B*48:44")
    assert result.__class__ is Allele, f'Expected parse("B*48:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_45():
    result = parse("B*48:45")
    assert result.__class__ is Allele, f'Expected parse("B*48:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_46():
    result = parse("B*48:46")
    assert result.__class__ is Allele, f'Expected parse("B*48:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_47():
    result = parse("B*48:47")
    assert result.__class__ is Allele, f'Expected parse("B*48:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_48():
    result = parse("B*48:48")
    assert result.__class__ is Allele, f'Expected parse("B*48:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_49():
    result = parse("B*48:49")
    assert result.__class__ is Allele, f'Expected parse("B*48:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_48_50():
    result = parse("B*48:50")
    assert result.__class__ is Allele, f'Expected parse("B*48:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*48:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_01_01():
    result = parse("B*49:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*49:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*49:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_01_02():
    result = parse("B*49:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*49:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*49:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_01_03():
    result = parse("B*49:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*49:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*49:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_01_04():
    result = parse("B*49:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*49:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*49:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_01_05():
    result = parse("B*49:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*49:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*49:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_01_06():
    result = parse("B*49:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*49:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*49:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_01_07():
    result = parse("B*49:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*49:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*49:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_01_08():
    result = parse("B*49:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*49:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*49:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_01_09():
    result = parse("B*49:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*49:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*49:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_01_10():
    result = parse("B*49:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*49:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*49:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_01_11():
    result = parse("B*49:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*49:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*49:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_02():
    result = parse("B*49:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*49:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_03():
    result = parse("B*49:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*49:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_04():
    result = parse("B*49:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*49:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_05():
    result = parse("B*49:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*49:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_06():
    result = parse("B*49:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*49:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_07():
    result = parse("B*49:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*49:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_08():
    result = parse("B*49:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*49:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_09():
    result = parse("B*49:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*49:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_10():
    result = parse("B*49:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*49:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_11():
    result = parse("B*49:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*49:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_12():
    result = parse("B*49:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*49:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_13():
    result = parse("B*49:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*49:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_14():
    result = parse("B*49:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*49:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_15():
    result = parse("B*49:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*49:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_01_16():
    result = parse("B*49:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*49:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_02():
    result = parse("B*49:02")
    assert result.__class__ is Allele, f'Expected parse("B*49:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_03():
    result = parse("B*49:03")
    assert result.__class__ is Allele, f'Expected parse("B*49:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_04_01():
    result = parse("B*49:04:01")
    assert result.__class__ is Allele, f'Expected parse("B*49:04:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_04_02():
    result = parse("B*49:04:02")
    assert result.__class__ is Allele, f'Expected parse("B*49:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_05_01():
    result = parse("B*49:05:01")
    assert result.__class__ is Allele, f'Expected parse("B*49:05:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_05_02():
    result = parse("B*49:05:02")
    assert result.__class__ is Allele, f'Expected parse("B*49:05:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_06():
    result = parse("B*49:06")
    assert result.__class__ is Allele, f'Expected parse("B*49:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_07():
    result = parse("B*49:07")
    assert result.__class__ is Allele, f'Expected parse("B*49:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_08():
    result = parse("B*49:08")
    assert result.__class__ is Allele, f'Expected parse("B*49:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_09():
    result = parse("B*49:09")
    assert result.__class__ is Allele, f'Expected parse("B*49:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_10():
    result = parse("B*49:10")
    assert result.__class__ is Allele, f'Expected parse("B*49:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_11():
    result = parse("B*49:11")
    assert result.__class__ is Allele, f'Expected parse("B*49:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_12():
    result = parse("B*49:12")
    assert result.__class__ is Allele, f'Expected parse("B*49:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_13():
    result = parse("B*49:13")
    assert result.__class__ is Allele, f'Expected parse("B*49:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_14():
    result = parse("B*49:14")
    assert result.__class__ is Allele, f'Expected parse("B*49:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_16():
    result = parse("B*49:16")
    assert result.__class__ is Allele, f'Expected parse("B*49:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_17():
    result = parse("B*49:17")
    assert result.__class__ is Allele, f'Expected parse("B*49:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_18_01():
    result = parse("B*49:18:01")
    assert result.__class__ is Allele, f'Expected parse("B*49:18:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:18:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_18_02():
    result = parse("B*49:18:02")
    assert result.__class__ is Allele, f'Expected parse("B*49:18:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:18:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_19N():
    result = parse("B*49:19N")
    assert result.__class__ is Allele, f'Expected parse("B*49:19N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:19N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_20():
    result = parse("B*49:20")
    assert result.__class__ is Allele, f'Expected parse("B*49:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_21():
    result = parse("B*49:21")
    assert result.__class__ is Allele, f'Expected parse("B*49:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_22():
    result = parse("B*49:22")
    assert result.__class__ is Allele, f'Expected parse("B*49:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_23():
    result = parse("B*49:23")
    assert result.__class__ is Allele, f'Expected parse("B*49:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_24():
    result = parse("B*49:24")
    assert result.__class__ is Allele, f'Expected parse("B*49:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_25():
    result = parse("B*49:25")
    assert result.__class__ is Allele, f'Expected parse("B*49:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_26():
    result = parse("B*49:26")
    assert result.__class__ is Allele, f'Expected parse("B*49:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_27():
    result = parse("B*49:27")
    assert result.__class__ is Allele, f'Expected parse("B*49:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_28():
    result = parse("B*49:28")
    assert result.__class__ is Allele, f'Expected parse("B*49:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_29():
    result = parse("B*49:29")
    assert result.__class__ is Allele, f'Expected parse("B*49:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_30():
    result = parse("B*49:30")
    assert result.__class__ is Allele, f'Expected parse("B*49:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_31():
    result = parse("B*49:31")
    assert result.__class__ is Allele, f'Expected parse("B*49:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_32():
    result = parse("B*49:32")
    assert result.__class__ is Allele, f'Expected parse("B*49:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_33():
    result = parse("B*49:33")
    assert result.__class__ is Allele, f'Expected parse("B*49:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_34():
    result = parse("B*49:34")
    assert result.__class__ is Allele, f'Expected parse("B*49:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_35():
    result = parse("B*49:35")
    assert result.__class__ is Allele, f'Expected parse("B*49:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_36():
    result = parse("B*49:36")
    assert result.__class__ is Allele, f'Expected parse("B*49:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_37():
    result = parse("B*49:37")
    assert result.__class__ is Allele, f'Expected parse("B*49:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_38():
    result = parse("B*49:38")
    assert result.__class__ is Allele, f'Expected parse("B*49:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_39():
    result = parse("B*49:39")
    assert result.__class__ is Allele, f'Expected parse("B*49:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_40():
    result = parse("B*49:40")
    assert result.__class__ is Allele, f'Expected parse("B*49:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_41():
    result = parse("B*49:41")
    assert result.__class__ is Allele, f'Expected parse("B*49:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_42():
    result = parse("B*49:42")
    assert result.__class__ is Allele, f'Expected parse("B*49:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_43():
    result = parse("B*49:43")
    assert result.__class__ is Allele, f'Expected parse("B*49:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_44():
    result = parse("B*49:44")
    assert result.__class__ is Allele, f'Expected parse("B*49:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_45():
    result = parse("B*49:45")
    assert result.__class__ is Allele, f'Expected parse("B*49:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_46():
    result = parse("B*49:46")
    assert result.__class__ is Allele, f'Expected parse("B*49:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_47_01():
    result = parse("B*49:47:01")
    assert result.__class__ is Allele, f'Expected parse("B*49:47:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:47:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_47_02():
    result = parse("B*49:47:02")
    assert result.__class__ is Allele, f'Expected parse("B*49:47:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*49:47:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_48():
    result = parse("B*49:48")
    assert result.__class__ is Allele, f'Expected parse("B*49:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_49():
    result = parse("B*49:49")
    assert result.__class__ is Allele, f'Expected parse("B*49:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_50():
    result = parse("B*49:50")
    assert result.__class__ is Allele, f'Expected parse("B*49:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_51():
    result = parse("B*49:51")
    assert result.__class__ is Allele, f'Expected parse("B*49:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_52():
    result = parse("B*49:52")
    assert result.__class__ is Allele, f'Expected parse("B*49:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_53():
    result = parse("B*49:53")
    assert result.__class__ is Allele, f'Expected parse("B*49:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_54():
    result = parse("B*49:54")
    assert result.__class__ is Allele, f'Expected parse("B*49:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_55():
    result = parse("B*49:55")
    assert result.__class__ is Allele, f'Expected parse("B*49:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_56():
    result = parse("B*49:56")
    assert result.__class__ is Allele, f'Expected parse("B*49:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_57():
    result = parse("B*49:57")
    assert result.__class__ is Allele, f'Expected parse("B*49:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_58():
    result = parse("B*49:58")
    assert result.__class__ is Allele, f'Expected parse("B*49:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_59():
    result = parse("B*49:59")
    assert result.__class__ is Allele, f'Expected parse("B*49:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_60N():
    result = parse("B*49:60N")
    assert result.__class__ is Allele, f'Expected parse("B*49:60N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:60N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_61():
    result = parse("B*49:61")
    assert result.__class__ is Allele, f'Expected parse("B*49:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_62():
    result = parse("B*49:62")
    assert result.__class__ is Allele, f'Expected parse("B*49:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_63():
    result = parse("B*49:63")
    assert result.__class__ is Allele, f'Expected parse("B*49:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_64():
    result = parse("B*49:64")
    assert result.__class__ is Allele, f'Expected parse("B*49:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_65():
    result = parse("B*49:65")
    assert result.__class__ is Allele, f'Expected parse("B*49:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_66():
    result = parse("B*49:66")
    assert result.__class__ is Allele, f'Expected parse("B*49:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_67():
    result = parse("B*49:67")
    assert result.__class__ is Allele, f'Expected parse("B*49:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_49_68():
    result = parse("B*49:68")
    assert result.__class__ is Allele, f'Expected parse("B*49:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*49:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_01_01():
    result = parse("B*50:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*50:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*50:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_01_02():
    result = parse("B*50:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*50:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*50:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_01_03():
    result = parse("B*50:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*50:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*50:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_01_04():
    result = parse("B*50:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*50:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*50:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_01_05():
    result = parse("B*50:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*50:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*50:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_01_06():
    result = parse("B*50:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*50:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*50:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_02():
    result = parse("B*50:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*50:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*50:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_03():
    result = parse("B*50:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*50:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*50:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_04():
    result = parse("B*50:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*50:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*50:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_05():
    result = parse("B*50:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*50:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*50:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_06():
    result = parse("B*50:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*50:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*50:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_07():
    result = parse("B*50:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*50:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*50:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_08():
    result = parse("B*50:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*50:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*50:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_09():
    result = parse("B*50:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*50:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*50:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_10():
    result = parse("B*50:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*50:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*50:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_11():
    result = parse("B*50:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*50:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*50:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_12():
    result = parse("B*50:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*50:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*50:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_13():
    result = parse("B*50:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*50:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*50:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_14():
    result = parse("B*50:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*50:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*50:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_15():
    result = parse("B*50:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*50:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*50:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_01_16():
    result = parse("B*50:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*50:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*50:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_02_01_01():
    result = parse("B*50:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*50:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*50:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_02_01_02():
    result = parse("B*50:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*50:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*50:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_04():
    result = parse("B*50:04")
    assert result.__class__ is Allele, f'Expected parse("B*50:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_05():
    result = parse("B*50:05")
    assert result.__class__ is Allele, f'Expected parse("B*50:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_06():
    result = parse("B*50:06")
    assert result.__class__ is Allele, f'Expected parse("B*50:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_07():
    result = parse("B*50:07")
    assert result.__class__ is Allele, f'Expected parse("B*50:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_08():
    result = parse("B*50:08")
    assert result.__class__ is Allele, f'Expected parse("B*50:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_09():
    result = parse("B*50:09")
    assert result.__class__ is Allele, f'Expected parse("B*50:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_10():
    result = parse("B*50:10")
    assert result.__class__ is Allele, f'Expected parse("B*50:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_11():
    result = parse("B*50:11")
    assert result.__class__ is Allele, f'Expected parse("B*50:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_12():
    result = parse("B*50:12")
    assert result.__class__ is Allele, f'Expected parse("B*50:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_13():
    result = parse("B*50:13")
    assert result.__class__ is Allele, f'Expected parse("B*50:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_14():
    result = parse("B*50:14")
    assert result.__class__ is Allele, f'Expected parse("B*50:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_15():
    result = parse("B*50:15")
    assert result.__class__ is Allele, f'Expected parse("B*50:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_16():
    result = parse("B*50:16")
    assert result.__class__ is Allele, f'Expected parse("B*50:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_17():
    result = parse("B*50:17")
    assert result.__class__ is Allele, f'Expected parse("B*50:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_18():
    result = parse("B*50:18")
    assert result.__class__ is Allele, f'Expected parse("B*50:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_19():
    result = parse("B*50:19")
    assert result.__class__ is Allele, f'Expected parse("B*50:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_20():
    result = parse("B*50:20")
    assert result.__class__ is Allele, f'Expected parse("B*50:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_31():
    result = parse("B*50:31")
    assert result.__class__ is Allele, f'Expected parse("B*50:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_32():
    result = parse("B*50:32")
    assert result.__class__ is Allele, f'Expected parse("B*50:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_33():
    result = parse("B*50:33")
    assert result.__class__ is Allele, f'Expected parse("B*50:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_34():
    result = parse("B*50:34")
    assert result.__class__ is Allele, f'Expected parse("B*50:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_35():
    result = parse("B*50:35")
    assert result.__class__ is Allele, f'Expected parse("B*50:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_36():
    result = parse("B*50:36")
    assert result.__class__ is Allele, f'Expected parse("B*50:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_37():
    result = parse("B*50:37")
    assert result.__class__ is Allele, f'Expected parse("B*50:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_38():
    result = parse("B*50:38")
    assert result.__class__ is Allele, f'Expected parse("B*50:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_39():
    result = parse("B*50:39")
    assert result.__class__ is Allele, f'Expected parse("B*50:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_40():
    result = parse("B*50:40")
    assert result.__class__ is Allele, f'Expected parse("B*50:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_41():
    result = parse("B*50:41")
    assert result.__class__ is Allele, f'Expected parse("B*50:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_42():
    result = parse("B*50:42")
    assert result.__class__ is Allele, f'Expected parse("B*50:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_43():
    result = parse("B*50:43")
    assert result.__class__ is Allele, f'Expected parse("B*50:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_44():
    result = parse("B*50:44")
    assert result.__class__ is Allele, f'Expected parse("B*50:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_45():
    result = parse("B*50:45")
    assert result.__class__ is Allele, f'Expected parse("B*50:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_46():
    result = parse("B*50:46")
    assert result.__class__ is Allele, f'Expected parse("B*50:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_47():
    result = parse("B*50:47")
    assert result.__class__ is Allele, f'Expected parse("B*50:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_48():
    result = parse("B*50:48")
    assert result.__class__ is Allele, f'Expected parse("B*50:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_49():
    result = parse("B*50:49")
    assert result.__class__ is Allele, f'Expected parse("B*50:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_50():
    result = parse("B*50:50")
    assert result.__class__ is Allele, f'Expected parse("B*50:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_51():
    result = parse("B*50:51")
    assert result.__class__ is Allele, f'Expected parse("B*50:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_52():
    result = parse("B*50:52")
    assert result.__class__ is Allele, f'Expected parse("B*50:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_53():
    result = parse("B*50:53")
    assert result.__class__ is Allele, f'Expected parse("B*50:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_54():
    result = parse("B*50:54")
    assert result.__class__ is Allele, f'Expected parse("B*50:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_55():
    result = parse("B*50:55")
    assert result.__class__ is Allele, f'Expected parse("B*50:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_56():
    result = parse("B*50:56")
    assert result.__class__ is Allele, f'Expected parse("B*50:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_57():
    result = parse("B*50:57")
    assert result.__class__ is Allele, f'Expected parse("B*50:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_58():
    result = parse("B*50:58")
    assert result.__class__ is Allele, f'Expected parse("B*50:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_59():
    result = parse("B*50:59")
    assert result.__class__ is Allele, f'Expected parse("B*50:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_60():
    result = parse("B*50:60")
    assert result.__class__ is Allele, f'Expected parse("B*50:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_61():
    result = parse("B*50:61")
    assert result.__class__ is Allele, f'Expected parse("B*50:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_62():
    result = parse("B*50:62")
    assert result.__class__ is Allele, f'Expected parse("B*50:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_63():
    result = parse("B*50:63")
    assert result.__class__ is Allele, f'Expected parse("B*50:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_64():
    result = parse("B*50:64")
    assert result.__class__ is Allele, f'Expected parse("B*50:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_65():
    result = parse("B*50:65")
    assert result.__class__ is Allele, f'Expected parse("B*50:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_66():
    result = parse("B*50:66")
    assert result.__class__ is Allele, f'Expected parse("B*50:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_67():
    result = parse("B*50:67")
    assert result.__class__ is Allele, f'Expected parse("B*50:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_68():
    result = parse("B*50:68")
    assert result.__class__ is Allele, f'Expected parse("B*50:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_69():
    result = parse("B*50:69")
    assert result.__class__ is Allele, f'Expected parse("B*50:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_50_70():
    result = parse("B*50:70")
    assert result.__class__ is Allele, f'Expected parse("B*50:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*50:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_01():
    result = parse("B*51:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_02():
    result = parse("B*51:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_03():
    result = parse("B*51:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_04():
    result = parse("B*51:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_05():
    result = parse("B*51:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_06():
    result = parse("B*51:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_07():
    result = parse("B*51:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_08():
    result = parse("B*51:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_09():
    result = parse("B*51:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_10():
    result = parse("B*51:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_11():
    result = parse("B*51:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_12():
    result = parse("B*51:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_13():
    result = parse("B*51:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_14():
    result = parse("B*51:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_15():
    result = parse("B*51:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_16():
    result = parse("B*51:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_17():
    result = parse("B*51:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_18():
    result = parse("B*51:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_19():
    result = parse("B*51:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_20():
    result = parse("B*51:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_21():
    result = parse("B*51:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_22():
    result = parse("B*51:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_23():
    result = parse("B*51:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_24():
    result = parse("B*51:01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_25():
    result = parse("B*51:01:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_26():
    result = parse("B*51:01:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_27():
    result = parse("B*51:01:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_28():
    result = parse("B*51:01:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_29():
    result = parse("B*51:01:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_30():
    result = parse("B*51:01:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_31():
    result = parse("B*51:01:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_32():
    result = parse("B*51:01:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_33():
    result = parse("B*51:01:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_34():
    result = parse("B*51:01:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_35():
    result = parse("B*51:01:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_36():
    result = parse("B*51:01:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_37():
    result = parse("B*51:01:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_38():
    result = parse("B*51:01:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_39():
    result = parse("B*51:01:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_40():
    result = parse("B*51:01:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_41():
    result = parse("B*51:01:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_42():
    result = parse("B*51:01:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_43():
    result = parse("B*51:01:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_44():
    result = parse("B*51:01:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_45():
    result = parse("B*51:01:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:45") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_46():
    result = parse("B*51:01:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:46") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_47():
    result = parse("B*51:01:01:47")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:47") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_48():
    result = parse("B*51:01:01:48")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:48") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:48") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_49():
    result = parse("B*51:01:01:49")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:49") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:49") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_50():
    result = parse("B*51:01:01:50")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:50") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:50") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_51():
    result = parse("B*51:01:01:51")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:51") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:51") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_52():
    result = parse("B*51:01:01:52")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:52") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:52") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_53():
    result = parse("B*51:01:01:53")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:53") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:53") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_54():
    result = parse("B*51:01:01:54")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:54") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:54") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_55():
    result = parse("B*51:01:01:55")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:55") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:55") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_56():
    result = parse("B*51:01:01:56")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:56") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:56") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_57():
    result = parse("B*51:01:01:57")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:57") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:57") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_58():
    result = parse("B*51:01:01:58")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:58") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:58") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_59():
    result = parse("B*51:01:01:59")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:59") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:59") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_60():
    result = parse("B*51:01:01:60")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:60") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:60") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_61():
    result = parse("B*51:01:01:61")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:61") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:61") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_62():
    result = parse("B*51:01:01:62")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:62") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:62") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_63():
    result = parse("B*51:01:01:63")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:63") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:63") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_01_64():
    result = parse("B*51:01:01:64")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:01:64") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:01:64") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_02_01():
    result = parse("B*51:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_02_02():
    result = parse("B*51:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_03():
    result = parse("B*51:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_04():
    result = parse("B*51:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_05():
    result = parse("B*51:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_06():
    result = parse("B*51:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_07():
    result = parse("B*51:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_08():
    result = parse("B*51:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_09():
    result = parse("B*51:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_10():
    result = parse("B*51:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_11():
    result = parse("B*51:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_12():
    result = parse("B*51:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_13():
    result = parse("B*51:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_14():
    result = parse("B*51:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_15():
    result = parse("B*51:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_16():
    result = parse("B*51:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_17():
    result = parse("B*51:01:17")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_18():
    result = parse("B*51:01:18")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_19():
    result = parse("B*51:01:19")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_20():
    result = parse("B*51:01:20")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_21():
    result = parse("B*51:01:21")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_22():
    result = parse("B*51:01:22")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_23():
    result = parse("B*51:01:23")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_24():
    result = parse("B*51:01:24")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_25():
    result = parse("B*51:01:25")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_26():
    result = parse("B*51:01:26")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_27():
    result = parse("B*51:01:27")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_28():
    result = parse("B*51:01:28")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_29():
    result = parse("B*51:01:29")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_30():
    result = parse("B*51:01:30")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_31():
    result = parse("B*51:01:31")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_32():
    result = parse("B*51:01:32")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_33():
    result = parse("B*51:01:33")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_34():
    result = parse("B*51:01:34")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_35():
    result = parse("B*51:01:35")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_36():
    result = parse("B*51:01:36")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_37():
    result = parse("B*51:01:37")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_38():
    result = parse("B*51:01:38")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_39():
    result = parse("B*51:01:39")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_40():
    result = parse("B*51:01:40")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_41():
    result = parse("B*51:01:41")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_42():
    result = parse("B*51:01:42")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_43():
    result = parse("B*51:01:43")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_44():
    result = parse("B*51:01:44")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_45():
    result = parse("B*51:01:45")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_46():
    result = parse("B*51:01:46")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_47():
    result = parse("B*51:01:47")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_48():
    result = parse("B*51:01:48")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_49():
    result = parse("B*51:01:49")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_50():
    result = parse("B*51:01:50")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_51():
    result = parse("B*51:01:51")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_52():
    result = parse("B*51:01:52")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_53():
    result = parse("B*51:01:53")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_54():
    result = parse("B*51:01:54")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_55():
    result = parse("B*51:01:55")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_56():
    result = parse("B*51:01:56")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_57():
    result = parse("B*51:01:57")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_58():
    result = parse("B*51:01:58")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_59():
    result = parse("B*51:01:59")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_60():
    result = parse("B*51:01:60")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_61():
    result = parse("B*51:01:61")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_62():
    result = parse("B*51:01:62")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_63():
    result = parse("B*51:01:63")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_64():
    result = parse("B*51:01:64")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_65():
    result = parse("B*51:01:65")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_66():
    result = parse("B*51:01:66")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:66") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:66") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_67():
    result = parse("B*51:01:67")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:67") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:67") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_68():
    result = parse("B*51:01:68")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:68") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:68") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_69():
    result = parse("B*51:01:69")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:69") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:69") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_70():
    result = parse("B*51:01:70")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:70") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:70") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_71():
    result = parse("B*51:01:71")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:71") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:71") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_72():
    result = parse("B*51:01:72")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:72") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:72") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_73():
    result = parse("B*51:01:73")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:73") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:73") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_74():
    result = parse("B*51:01:74")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:74") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:74") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_75():
    result = parse("B*51:01:75")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:75") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:75") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_76():
    result = parse("B*51:01:76")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:76") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:76") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_77():
    result = parse("B*51:01:77")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:77") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:77") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_78():
    result = parse("B*51:01:78")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:78") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:78") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_79():
    result = parse("B*51:01:79")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:79") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:79") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_80():
    result = parse("B*51:01:80")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:80") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:80") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_81():
    result = parse("B*51:01:81")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:81") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:81") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_82():
    result = parse("B*51:01:82")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:82") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:82") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_83():
    result = parse("B*51:01:83")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:83") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:83") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_01_84():
    result = parse("B*51:01:84")
    assert result.__class__ is Allele, f'Expected parse("B*51:01:84") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:01:84") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_02_01_01():
    result = parse("B*51:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_02_01_02():
    result = parse("B*51:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_02_02():
    result = parse("B*51:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*51:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_02_03():
    result = parse("B*51:02:03")
    assert result.__class__ is Allele, f'Expected parse("B*51:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_02_04():
    result = parse("B*51:02:04")
    assert result.__class__ is Allele, f'Expected parse("B*51:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_02_05():
    result = parse("B*51:02:05")
    assert result.__class__ is Allele, f'Expected parse("B*51:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_02_06():
    result = parse("B*51:02:06")
    assert result.__class__ is Allele, f'Expected parse("B*51:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_03():
    result = parse("B*51:03")
    assert result.__class__ is Allele, f'Expected parse("B*51:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_04_01():
    result = parse("B*51:04:01")
    assert result.__class__ is Allele, f'Expected parse("B*51:04:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_04_02():
    result = parse("B*51:04:02")
    assert result.__class__ is Allele, f'Expected parse("B*51:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_05():
    result = parse("B*51:05")
    assert result.__class__ is Allele, f'Expected parse("B*51:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_06_01():
    result = parse("B*51:06:01")
    assert result.__class__ is Allele, f'Expected parse("B*51:06:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_06_02():
    result = parse("B*51:06:02")
    assert result.__class__ is Allele, f'Expected parse("B*51:06:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_06_03():
    result = parse("B*51:06:03")
    assert result.__class__ is Allele, f'Expected parse("B*51:06:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:06:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_06_04():
    result = parse("B*51:06:04")
    assert result.__class__ is Allele, f'Expected parse("B*51:06:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:06:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_07_01():
    result = parse("B*51:07:01")
    assert result.__class__ is Allele, f'Expected parse("B*51:07:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_07_02():
    result = parse("B*51:07:02")
    assert result.__class__ is Allele, f'Expected parse("B*51:07:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_08_01_01():
    result = parse("B*51:08:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:08:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:08:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_08_01_02():
    result = parse("B*51:08:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:08:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:08:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_08_02():
    result = parse("B*51:08:02")
    assert result.__class__ is Allele, f'Expected parse("B*51:08:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:08:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_08_03():
    result = parse("B*51:08:03")
    assert result.__class__ is Allele, f'Expected parse("B*51:08:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:08:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_08_04():
    result = parse("B*51:08:04")
    assert result.__class__ is Allele, f'Expected parse("B*51:08:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:08:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_09_01():
    result = parse("B*51:09:01")
    assert result.__class__ is Allele, f'Expected parse("B*51:09:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:09:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_09_02():
    result = parse("B*51:09:02")
    assert result.__class__ is Allele, f'Expected parse("B*51:09:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:09:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_09_03():
    result = parse("B*51:09:03")
    assert result.__class__ is Allele, f'Expected parse("B*51:09:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:09:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_10():
    result = parse("B*51:10")
    assert result.__class__ is Allele, f'Expected parse("B*51:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_100():
    result = parse("B*51:100")
    assert result.__class__ is Allele, f'Expected parse("B*51:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_101():
    result = parse("B*51:101")
    assert result.__class__ is Allele, f'Expected parse("B*51:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_102():
    result = parse("B*51:102")
    assert result.__class__ is Allele, f'Expected parse("B*51:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_103():
    result = parse("B*51:103")
    assert result.__class__ is Allele, f'Expected parse("B*51:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_104():
    result = parse("B*51:104")
    assert result.__class__ is Allele, f'Expected parse("B*51:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_105():
    result = parse("B*51:105")
    assert result.__class__ is Allele, f'Expected parse("B*51:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_106_01():
    result = parse("B*51:106:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:106:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:106:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_106_02():
    result = parse("B*51:106:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:106:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:106:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_107():
    result = parse("B*51:107")
    assert result.__class__ is Allele, f'Expected parse("B*51:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_108():
    result = parse("B*51:108")
    assert result.__class__ is Allele, f'Expected parse("B*51:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_109():
    result = parse("B*51:109")
    assert result.__class__ is Allele, f'Expected parse("B*51:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_110N():
    result = parse("B*51:110N")
    assert result.__class__ is Allele, f'Expected parse("B*51:110N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:110N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_111():
    result = parse("B*51:111")
    assert result.__class__ is Allele, f'Expected parse("B*51:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_112():
    result = parse("B*51:112")
    assert result.__class__ is Allele, f'Expected parse("B*51:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_113():
    result = parse("B*51:113")
    assert result.__class__ is Allele, f'Expected parse("B*51:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_114():
    result = parse("B*51:114")
    assert result.__class__ is Allele, f'Expected parse("B*51:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_115():
    result = parse("B*51:115")
    assert result.__class__ is Allele, f'Expected parse("B*51:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_116():
    result = parse("B*51:116")
    assert result.__class__ is Allele, f'Expected parse("B*51:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_117():
    result = parse("B*51:117")
    assert result.__class__ is Allele, f'Expected parse("B*51:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_118N():
    result = parse("B*51:118N")
    assert result.__class__ is Allele, f'Expected parse("B*51:118N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:118N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_119():
    result = parse("B*51:119")
    assert result.__class__ is Allele, f'Expected parse("B*51:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_11N():
    result = parse("B*51:11N")
    assert result.__class__ is Allele, f'Expected parse("B*51:11N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:11N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_12():
    result = parse("B*51:12")
    assert result.__class__ is Allele, f'Expected parse("B*51:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_120():
    result = parse("B*51:120")
    assert result.__class__ is Allele, f'Expected parse("B*51:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_121():
    result = parse("B*51:121")
    assert result.__class__ is Allele, f'Expected parse("B*51:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_122():
    result = parse("B*51:122")
    assert result.__class__ is Allele, f'Expected parse("B*51:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_123():
    result = parse("B*51:123")
    assert result.__class__ is Allele, f'Expected parse("B*51:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_124():
    result = parse("B*51:124")
    assert result.__class__ is Allele, f'Expected parse("B*51:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_125():
    result = parse("B*51:125")
    assert result.__class__ is Allele, f'Expected parse("B*51:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_126():
    result = parse("B*51:126")
    assert result.__class__ is Allele, f'Expected parse("B*51:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_127():
    result = parse("B*51:127")
    assert result.__class__ is Allele, f'Expected parse("B*51:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_128():
    result = parse("B*51:128")
    assert result.__class__ is Allele, f'Expected parse("B*51:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_129():
    result = parse("B*51:129")
    assert result.__class__ is Allele, f'Expected parse("B*51:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_130():
    result = parse("B*51:130")
    assert result.__class__ is Allele, f'Expected parse("B*51:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_131():
    result = parse("B*51:131")
    assert result.__class__ is Allele, f'Expected parse("B*51:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_132():
    result = parse("B*51:132")
    assert result.__class__ is Allele, f'Expected parse("B*51:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_133():
    result = parse("B*51:133")
    assert result.__class__ is Allele, f'Expected parse("B*51:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_134():
    result = parse("B*51:134")
    assert result.__class__ is Allele, f'Expected parse("B*51:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_135():
    result = parse("B*51:135")
    assert result.__class__ is Allele, f'Expected parse("B*51:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_136():
    result = parse("B*51:136")
    assert result.__class__ is Allele, f'Expected parse("B*51:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_137():
    result = parse("B*51:137")
    assert result.__class__ is Allele, f'Expected parse("B*51:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_138():
    result = parse("B*51:138")
    assert result.__class__ is Allele, f'Expected parse("B*51:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_139():
    result = parse("B*51:139")
    assert result.__class__ is Allele, f'Expected parse("B*51:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_13_01():
    result = parse("B*51:13:01")
    assert result.__class__ is Allele, f'Expected parse("B*51:13:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:13:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_13_02():
    result = parse("B*51:13:02")
    assert result.__class__ is Allele, f'Expected parse("B*51:13:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:13:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_14():
    result = parse("B*51:14")
    assert result.__class__ is Allele, f'Expected parse("B*51:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_140():
    result = parse("B*51:140")
    assert result.__class__ is Allele, f'Expected parse("B*51:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_141():
    result = parse("B*51:141")
    assert result.__class__ is Allele, f'Expected parse("B*51:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_142():
    result = parse("B*51:142")
    assert result.__class__ is Allele, f'Expected parse("B*51:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_143():
    result = parse("B*51:143")
    assert result.__class__ is Allele, f'Expected parse("B*51:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_144():
    result = parse("B*51:144")
    assert result.__class__ is Allele, f'Expected parse("B*51:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_145():
    result = parse("B*51:145")
    assert result.__class__ is Allele, f'Expected parse("B*51:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_146():
    result = parse("B*51:146")
    assert result.__class__ is Allele, f'Expected parse("B*51:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_147():
    result = parse("B*51:147")
    assert result.__class__ is Allele, f'Expected parse("B*51:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_148():
    result = parse("B*51:148")
    assert result.__class__ is Allele, f'Expected parse("B*51:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_149N():
    result = parse("B*51:149N")
    assert result.__class__ is Allele, f'Expected parse("B*51:149N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:149N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_15():
    result = parse("B*51:15")
    assert result.__class__ is Allele, f'Expected parse("B*51:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_150():
    result = parse("B*51:150")
    assert result.__class__ is Allele, f'Expected parse("B*51:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_151():
    result = parse("B*51:151")
    assert result.__class__ is Allele, f'Expected parse("B*51:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_152():
    result = parse("B*51:152")
    assert result.__class__ is Allele, f'Expected parse("B*51:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_153():
    result = parse("B*51:153")
    assert result.__class__ is Allele, f'Expected parse("B*51:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_154():
    result = parse("B*51:154")
    assert result.__class__ is Allele, f'Expected parse("B*51:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_155():
    result = parse("B*51:155")
    assert result.__class__ is Allele, f'Expected parse("B*51:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_156():
    result = parse("B*51:156")
    assert result.__class__ is Allele, f'Expected parse("B*51:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_157():
    result = parse("B*51:157")
    assert result.__class__ is Allele, f'Expected parse("B*51:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_158_01():
    result = parse("B*51:158:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:158:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:158:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_158_02():
    result = parse("B*51:158:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:158:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:158:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_159():
    result = parse("B*51:159")
    assert result.__class__ is Allele, f'Expected parse("B*51:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_16():
    result = parse("B*51:16")
    assert result.__class__ is Allele, f'Expected parse("B*51:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_160():
    result = parse("B*51:160")
    assert result.__class__ is Allele, f'Expected parse("B*51:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_161():
    result = parse("B*51:161")
    assert result.__class__ is Allele, f'Expected parse("B*51:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_162():
    result = parse("B*51:162")
    assert result.__class__ is Allele, f'Expected parse("B*51:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_163():
    result = parse("B*51:163")
    assert result.__class__ is Allele, f'Expected parse("B*51:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_164():
    result = parse("B*51:164")
    assert result.__class__ is Allele, f'Expected parse("B*51:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_165():
    result = parse("B*51:165")
    assert result.__class__ is Allele, f'Expected parse("B*51:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_166():
    result = parse("B*51:166")
    assert result.__class__ is Allele, f'Expected parse("B*51:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_167():
    result = parse("B*51:167")
    assert result.__class__ is Allele, f'Expected parse("B*51:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_168():
    result = parse("B*51:168")
    assert result.__class__ is Allele, f'Expected parse("B*51:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_169():
    result = parse("B*51:169")
    assert result.__class__ is Allele, f'Expected parse("B*51:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_17():
    result = parse("B*51:17")
    assert result.__class__ is Allele, f'Expected parse("B*51:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_170():
    result = parse("B*51:170")
    assert result.__class__ is Allele, f'Expected parse("B*51:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_171():
    result = parse("B*51:171")
    assert result.__class__ is Allele, f'Expected parse("B*51:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_172():
    result = parse("B*51:172")
    assert result.__class__ is Allele, f'Expected parse("B*51:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_173Q():
    result = parse("B*51:173Q")
    assert result.__class__ is Allele, f'Expected parse("B*51:173Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:173Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_174_01():
    result = parse("B*51:174:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:174:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:174:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_174_02():
    result = parse("B*51:174:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:174:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:174:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_175():
    result = parse("B*51:175")
    assert result.__class__ is Allele, f'Expected parse("B*51:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_176():
    result = parse("B*51:176")
    assert result.__class__ is Allele, f'Expected parse("B*51:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_177():
    result = parse("B*51:177")
    assert result.__class__ is Allele, f'Expected parse("B*51:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_178N():
    result = parse("B*51:178N")
    assert result.__class__ is Allele, f'Expected parse("B*51:178N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:178N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_179():
    result = parse("B*51:179")
    assert result.__class__ is Allele, f'Expected parse("B*51:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_18():
    result = parse("B*51:18")
    assert result.__class__ is Allele, f'Expected parse("B*51:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_180():
    result = parse("B*51:180")
    assert result.__class__ is Allele, f'Expected parse("B*51:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_181():
    result = parse("B*51:181")
    assert result.__class__ is Allele, f'Expected parse("B*51:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_182():
    result = parse("B*51:182")
    assert result.__class__ is Allele, f'Expected parse("B*51:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_183():
    result = parse("B*51:183")
    assert result.__class__ is Allele, f'Expected parse("B*51:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_184N():
    result = parse("B*51:184N")
    assert result.__class__ is Allele, f'Expected parse("B*51:184N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:184N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_185():
    result = parse("B*51:185")
    assert result.__class__ is Allele, f'Expected parse("B*51:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_186():
    result = parse("B*51:186")
    assert result.__class__ is Allele, f'Expected parse("B*51:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_187():
    result = parse("B*51:187")
    assert result.__class__ is Allele, f'Expected parse("B*51:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_188():
    result = parse("B*51:188")
    assert result.__class__ is Allele, f'Expected parse("B*51:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_189():
    result = parse("B*51:189")
    assert result.__class__ is Allele, f'Expected parse("B*51:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_19():
    result = parse("B*51:19")
    assert result.__class__ is Allele, f'Expected parse("B*51:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_190():
    result = parse("B*51:190")
    assert result.__class__ is Allele, f'Expected parse("B*51:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_191():
    result = parse("B*51:191")
    assert result.__class__ is Allele, f'Expected parse("B*51:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_192():
    result = parse("B*51:192")
    assert result.__class__ is Allele, f'Expected parse("B*51:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_193():
    result = parse("B*51:193")
    assert result.__class__ is Allele, f'Expected parse("B*51:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_194():
    result = parse("B*51:194")
    assert result.__class__ is Allele, f'Expected parse("B*51:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_195():
    result = parse("B*51:195")
    assert result.__class__ is Allele, f'Expected parse("B*51:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_196():
    result = parse("B*51:196")
    assert result.__class__ is Allele, f'Expected parse("B*51:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_197():
    result = parse("B*51:197")
    assert result.__class__ is Allele, f'Expected parse("B*51:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_198():
    result = parse("B*51:198")
    assert result.__class__ is Allele, f'Expected parse("B*51:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_199():
    result = parse("B*51:199")
    assert result.__class__ is Allele, f'Expected parse("B*51:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_20():
    result = parse("B*51:20")
    assert result.__class__ is Allele, f'Expected parse("B*51:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_200():
    result = parse("B*51:200")
    assert result.__class__ is Allele, f'Expected parse("B*51:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_201():
    result = parse("B*51:201")
    assert result.__class__ is Allele, f'Expected parse("B*51:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_202():
    result = parse("B*51:202")
    assert result.__class__ is Allele, f'Expected parse("B*51:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_203():
    result = parse("B*51:203")
    assert result.__class__ is Allele, f'Expected parse("B*51:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_204_01():
    result = parse("B*51:204:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:204:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:204:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_204_02():
    result = parse("B*51:204:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:204:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:204:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_205():
    result = parse("B*51:205")
    assert result.__class__ is Allele, f'Expected parse("B*51:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_206():
    result = parse("B*51:206")
    assert result.__class__ is Allele, f'Expected parse("B*51:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_207():
    result = parse("B*51:207")
    assert result.__class__ is Allele, f'Expected parse("B*51:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_208():
    result = parse("B*51:208")
    assert result.__class__ is Allele, f'Expected parse("B*51:208") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_209():
    result = parse("B*51:209")
    assert result.__class__ is Allele, f'Expected parse("B*51:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_21():
    result = parse("B*51:21")
    assert result.__class__ is Allele, f'Expected parse("B*51:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_210():
    result = parse("B*51:210")
    assert result.__class__ is Allele, f'Expected parse("B*51:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_211():
    result = parse("B*51:211")
    assert result.__class__ is Allele, f'Expected parse("B*51:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_212():
    result = parse("B*51:212")
    assert result.__class__ is Allele, f'Expected parse("B*51:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_213():
    result = parse("B*51:213")
    assert result.__class__ is Allele, f'Expected parse("B*51:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_214():
    result = parse("B*51:214")
    assert result.__class__ is Allele, f'Expected parse("B*51:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_215():
    result = parse("B*51:215")
    assert result.__class__ is Allele, f'Expected parse("B*51:215") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_216():
    result = parse("B*51:216")
    assert result.__class__ is Allele, f'Expected parse("B*51:216") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_217():
    result = parse("B*51:217")
    assert result.__class__ is Allele, f'Expected parse("B*51:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_218():
    result = parse("B*51:218")
    assert result.__class__ is Allele, f'Expected parse("B*51:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_219():
    result = parse("B*51:219")
    assert result.__class__ is Allele, f'Expected parse("B*51:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_22():
    result = parse("B*51:22")
    assert result.__class__ is Allele, f'Expected parse("B*51:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_220():
    result = parse("B*51:220")
    assert result.__class__ is Allele, f'Expected parse("B*51:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_221():
    result = parse("B*51:221")
    assert result.__class__ is Allele, f'Expected parse("B*51:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_222():
    result = parse("B*51:222")
    assert result.__class__ is Allele, f'Expected parse("B*51:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_223():
    result = parse("B*51:223")
    assert result.__class__ is Allele, f'Expected parse("B*51:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_224():
    result = parse("B*51:224")
    assert result.__class__ is Allele, f'Expected parse("B*51:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_225():
    result = parse("B*51:225")
    assert result.__class__ is Allele, f'Expected parse("B*51:225") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_226():
    result = parse("B*51:226")
    assert result.__class__ is Allele, f'Expected parse("B*51:226") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_227():
    result = parse("B*51:227")
    assert result.__class__ is Allele, f'Expected parse("B*51:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_228():
    result = parse("B*51:228")
    assert result.__class__ is Allele, f'Expected parse("B*51:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_229():
    result = parse("B*51:229")
    assert result.__class__ is Allele, f'Expected parse("B*51:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_23():
    result = parse("B*51:23")
    assert result.__class__ is Allele, f'Expected parse("B*51:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_230_01_01():
    result = parse("B*51:230:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:230:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:230:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_230_01_02():
    result = parse("B*51:230:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:230:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:230:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_230_01_03():
    result = parse("B*51:230:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*51:230:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*51:230:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_231():
    result = parse("B*51:231")
    assert result.__class__ is Allele, f'Expected parse("B*51:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_232():
    result = parse("B*51:232")
    assert result.__class__ is Allele, f'Expected parse("B*51:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_233():
    result = parse("B*51:233")
    assert result.__class__ is Allele, f'Expected parse("B*51:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_234():
    result = parse("B*51:234")
    assert result.__class__ is Allele, f'Expected parse("B*51:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_235N():
    result = parse("B*51:235N")
    assert result.__class__ is Allele, f'Expected parse("B*51:235N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:235N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_236():
    result = parse("B*51:236")
    assert result.__class__ is Allele, f'Expected parse("B*51:236") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_237():
    result = parse("B*51:237")
    assert result.__class__ is Allele, f'Expected parse("B*51:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_238():
    result = parse("B*51:238")
    assert result.__class__ is Allele, f'Expected parse("B*51:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_239():
    result = parse("B*51:239")
    assert result.__class__ is Allele, f'Expected parse("B*51:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_240():
    result = parse("B*51:240")
    assert result.__class__ is Allele, f'Expected parse("B*51:240") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_241():
    result = parse("B*51:241")
    assert result.__class__ is Allele, f'Expected parse("B*51:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_242():
    result = parse("B*51:242")
    assert result.__class__ is Allele, f'Expected parse("B*51:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_243():
    result = parse("B*51:243")
    assert result.__class__ is Allele, f'Expected parse("B*51:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_244():
    result = parse("B*51:244")
    assert result.__class__ is Allele, f'Expected parse("B*51:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_245N():
    result = parse("B*51:245N")
    assert result.__class__ is Allele, f'Expected parse("B*51:245N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:245N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_246():
    result = parse("B*51:246")
    assert result.__class__ is Allele, f'Expected parse("B*51:246") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_247():
    result = parse("B*51:247")
    assert result.__class__ is Allele, f'Expected parse("B*51:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_248():
    result = parse("B*51:248")
    assert result.__class__ is Allele, f'Expected parse("B*51:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_249():
    result = parse("B*51:249")
    assert result.__class__ is Allele, f'Expected parse("B*51:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_24_01():
    result = parse("B*51:24:01")
    assert result.__class__ is Allele, f'Expected parse("B*51:24:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:24:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_24_02():
    result = parse("B*51:24:02")
    assert result.__class__ is Allele, f'Expected parse("B*51:24:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:24:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_24_03():
    result = parse("B*51:24:03")
    assert result.__class__ is Allele, f'Expected parse("B*51:24:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:24:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_24_04():
    result = parse("B*51:24:04")
    assert result.__class__ is Allele, f'Expected parse("B*51:24:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:24:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_24_05():
    result = parse("B*51:24:05")
    assert result.__class__ is Allele, f'Expected parse("B*51:24:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:24:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_250():
    result = parse("B*51:250")
    assert result.__class__ is Allele, f'Expected parse("B*51:250") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_251():
    result = parse("B*51:251")
    assert result.__class__ is Allele, f'Expected parse("B*51:251") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_252():
    result = parse("B*51:252")
    assert result.__class__ is Allele, f'Expected parse("B*51:252") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_253():
    result = parse("B*51:253")
    assert result.__class__ is Allele, f'Expected parse("B*51:253") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_254():
    result = parse("B*51:254")
    assert result.__class__ is Allele, f'Expected parse("B*51:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_255():
    result = parse("B*51:255")
    assert result.__class__ is Allele, f'Expected parse("B*51:255") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_256N():
    result = parse("B*51:256N")
    assert result.__class__ is Allele, f'Expected parse("B*51:256N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:256N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_257():
    result = parse("B*51:257")
    assert result.__class__ is Allele, f'Expected parse("B*51:257") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_258():
    result = parse("B*51:258")
    assert result.__class__ is Allele, f'Expected parse("B*51:258") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_259():
    result = parse("B*51:259")
    assert result.__class__ is Allele, f'Expected parse("B*51:259") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_26():
    result = parse("B*51:26")
    assert result.__class__ is Allele, f'Expected parse("B*51:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_260():
    result = parse("B*51:260")
    assert result.__class__ is Allele, f'Expected parse("B*51:260") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_261():
    result = parse("B*51:261")
    assert result.__class__ is Allele, f'Expected parse("B*51:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_262():
    result = parse("B*51:262")
    assert result.__class__ is Allele, f'Expected parse("B*51:262") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_263():
    result = parse("B*51:263")
    assert result.__class__ is Allele, f'Expected parse("B*51:263") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_264N():
    result = parse("B*51:264N")
    assert result.__class__ is Allele, f'Expected parse("B*51:264N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:264N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_265():
    result = parse("B*51:265")
    assert result.__class__ is Allele, f'Expected parse("B*51:265") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_266():
    result = parse("B*51:266")
    assert result.__class__ is Allele, f'Expected parse("B*51:266") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_267():
    result = parse("B*51:267")
    assert result.__class__ is Allele, f'Expected parse("B*51:267") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_268():
    result = parse("B*51:268")
    assert result.__class__ is Allele, f'Expected parse("B*51:268") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_269():
    result = parse("B*51:269")
    assert result.__class__ is Allele, f'Expected parse("B*51:269") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_270():
    result = parse("B*51:270")
    assert result.__class__ is Allele, f'Expected parse("B*51:270") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_271():
    result = parse("B*51:271")
    assert result.__class__ is Allele, f'Expected parse("B*51:271") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_272():
    result = parse("B*51:272")
    assert result.__class__ is Allele, f'Expected parse("B*51:272") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_273N():
    result = parse("B*51:273N")
    assert result.__class__ is Allele, f'Expected parse("B*51:273N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:273N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_274():
    result = parse("B*51:274")
    assert result.__class__ is Allele, f'Expected parse("B*51:274") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_275():
    result = parse("B*51:275")
    assert result.__class__ is Allele, f'Expected parse("B*51:275") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_276():
    result = parse("B*51:276")
    assert result.__class__ is Allele, f'Expected parse("B*51:276") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_277():
    result = parse("B*51:277")
    assert result.__class__ is Allele, f'Expected parse("B*51:277") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_278():
    result = parse("B*51:278")
    assert result.__class__ is Allele, f'Expected parse("B*51:278") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_279():
    result = parse("B*51:279")
    assert result.__class__ is Allele, f'Expected parse("B*51:279") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_27N():
    result = parse("B*51:27N")
    assert result.__class__ is Allele, f'Expected parse("B*51:27N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:27N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_28():
    result = parse("B*51:28")
    assert result.__class__ is Allele, f'Expected parse("B*51:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_280():
    result = parse("B*51:280")
    assert result.__class__ is Allele, f'Expected parse("B*51:280") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_281():
    result = parse("B*51:281")
    assert result.__class__ is Allele, f'Expected parse("B*51:281") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_282():
    result = parse("B*51:282")
    assert result.__class__ is Allele, f'Expected parse("B*51:282") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_283():
    result = parse("B*51:283")
    assert result.__class__ is Allele, f'Expected parse("B*51:283") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_284():
    result = parse("B*51:284")
    assert result.__class__ is Allele, f'Expected parse("B*51:284") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_285():
    result = parse("B*51:285")
    assert result.__class__ is Allele, f'Expected parse("B*51:285") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_286():
    result = parse("B*51:286")
    assert result.__class__ is Allele, f'Expected parse("B*51:286") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_287N():
    result = parse("B*51:287N")
    assert result.__class__ is Allele, f'Expected parse("B*51:287N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:287N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_288():
    result = parse("B*51:288")
    assert result.__class__ is Allele, f'Expected parse("B*51:288") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_289():
    result = parse("B*51:289")
    assert result.__class__ is Allele, f'Expected parse("B*51:289") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_29():
    result = parse("B*51:29")
    assert result.__class__ is Allele, f'Expected parse("B*51:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_290():
    result = parse("B*51:290")
    assert result.__class__ is Allele, f'Expected parse("B*51:290") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_291():
    result = parse("B*51:291")
    assert result.__class__ is Allele, f'Expected parse("B*51:291") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_292():
    result = parse("B*51:292")
    assert result.__class__ is Allele, f'Expected parse("B*51:292") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_293():
    result = parse("B*51:293")
    assert result.__class__ is Allele, f'Expected parse("B*51:293") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_294():
    result = parse("B*51:294")
    assert result.__class__ is Allele, f'Expected parse("B*51:294") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_295():
    result = parse("B*51:295")
    assert result.__class__ is Allele, f'Expected parse("B*51:295") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_296():
    result = parse("B*51:296")
    assert result.__class__ is Allele, f'Expected parse("B*51:296") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_297():
    result = parse("B*51:297")
    assert result.__class__ is Allele, f'Expected parse("B*51:297") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_298():
    result = parse("B*51:298")
    assert result.__class__ is Allele, f'Expected parse("B*51:298") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_299():
    result = parse("B*51:299")
    assert result.__class__ is Allele, f'Expected parse("B*51:299") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_30():
    result = parse("B*51:30")
    assert result.__class__ is Allele, f'Expected parse("B*51:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_300():
    result = parse("B*51:300")
    assert result.__class__ is Allele, f'Expected parse("B*51:300") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_301():
    result = parse("B*51:301")
    assert result.__class__ is Allele, f'Expected parse("B*51:301") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_302():
    result = parse("B*51:302")
    assert result.__class__ is Allele, f'Expected parse("B*51:302") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_303():
    result = parse("B*51:303")
    assert result.__class__ is Allele, f'Expected parse("B*51:303") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:303") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_304():
    result = parse("B*51:304")
    assert result.__class__ is Allele, f'Expected parse("B*51:304") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:304") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_305():
    result = parse("B*51:305")
    assert result.__class__ is Allele, f'Expected parse("B*51:305") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_306N():
    result = parse("B*51:306N")
    assert result.__class__ is Allele, f'Expected parse("B*51:306N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:306N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_307():
    result = parse("B*51:307")
    assert result.__class__ is Allele, f'Expected parse("B*51:307") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_308():
    result = parse("B*51:308")
    assert result.__class__ is Allele, f'Expected parse("B*51:308") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:308") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_309():
    result = parse("B*51:309")
    assert result.__class__ is Allele, f'Expected parse("B*51:309") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:309") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_31():
    result = parse("B*51:31")
    assert result.__class__ is Allele, f'Expected parse("B*51:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_310():
    result = parse("B*51:310")
    assert result.__class__ is Allele, f'Expected parse("B*51:310") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:310") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_311():
    result = parse("B*51:311")
    assert result.__class__ is Allele, f'Expected parse("B*51:311") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:311") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_312():
    result = parse("B*51:312")
    assert result.__class__ is Allele, f'Expected parse("B*51:312") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:312") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_313N():
    result = parse("B*51:313N")
    assert result.__class__ is Allele, f'Expected parse("B*51:313N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:313N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_314():
    result = parse("B*51:314")
    assert result.__class__ is Allele, f'Expected parse("B*51:314") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:314") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_315():
    result = parse("B*51:315")
    assert result.__class__ is Allele, f'Expected parse("B*51:315") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:315") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_316():
    result = parse("B*51:316")
    assert result.__class__ is Allele, f'Expected parse("B*51:316") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:316") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_317():
    result = parse("B*51:317")
    assert result.__class__ is Allele, f'Expected parse("B*51:317") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:317") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_318N():
    result = parse("B*51:318N")
    assert result.__class__ is Allele, f'Expected parse("B*51:318N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:318N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_319():
    result = parse("B*51:319")
    assert result.__class__ is Allele, f'Expected parse("B*51:319") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_32():
    result = parse("B*51:32")
    assert result.__class__ is Allele, f'Expected parse("B*51:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_320():
    result = parse("B*51:320")
    assert result.__class__ is Allele, f'Expected parse("B*51:320") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:320") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_321():
    result = parse("B*51:321")
    assert result.__class__ is Allele, f'Expected parse("B*51:321") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:321") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_33():
    result = parse("B*51:33")
    assert result.__class__ is Allele, f'Expected parse("B*51:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_34():
    result = parse("B*51:34")
    assert result.__class__ is Allele, f'Expected parse("B*51:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_35():
    result = parse("B*51:35")
    assert result.__class__ is Allele, f'Expected parse("B*51:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_36():
    result = parse("B*51:36")
    assert result.__class__ is Allele, f'Expected parse("B*51:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_37():
    result = parse("B*51:37")
    assert result.__class__ is Allele, f'Expected parse("B*51:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_38():
    result = parse("B*51:38")
    assert result.__class__ is Allele, f'Expected parse("B*51:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_39():
    result = parse("B*51:39")
    assert result.__class__ is Allele, f'Expected parse("B*51:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_40():
    result = parse("B*51:40")
    assert result.__class__ is Allele, f'Expected parse("B*51:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_41N():
    result = parse("B*51:41N")
    assert result.__class__ is Allele, f'Expected parse("B*51:41N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:41N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_42():
    result = parse("B*51:42")
    assert result.__class__ is Allele, f'Expected parse("B*51:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_43():
    result = parse("B*51:43")
    assert result.__class__ is Allele, f'Expected parse("B*51:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_44N():
    result = parse("B*51:44N")
    assert result.__class__ is Allele, f'Expected parse("B*51:44N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:44N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_45():
    result = parse("B*51:45")
    assert result.__class__ is Allele, f'Expected parse("B*51:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_46():
    result = parse("B*51:46")
    assert result.__class__ is Allele, f'Expected parse("B*51:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_48():
    result = parse("B*51:48")
    assert result.__class__ is Allele, f'Expected parse("B*51:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_49():
    result = parse("B*51:49")
    assert result.__class__ is Allele, f'Expected parse("B*51:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_50():
    result = parse("B*51:50")
    assert result.__class__ is Allele, f'Expected parse("B*51:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_51():
    result = parse("B*51:51")
    assert result.__class__ is Allele, f'Expected parse("B*51:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_52():
    result = parse("B*51:52")
    assert result.__class__ is Allele, f'Expected parse("B*51:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_53():
    result = parse("B*51:53")
    assert result.__class__ is Allele, f'Expected parse("B*51:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_54():
    result = parse("B*51:54")
    assert result.__class__ is Allele, f'Expected parse("B*51:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_55():
    result = parse("B*51:55")
    assert result.__class__ is Allele, f'Expected parse("B*51:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_56_01():
    result = parse("B*51:56:01")
    assert result.__class__ is Allele, f'Expected parse("B*51:56:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:56:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_56_02():
    result = parse("B*51:56:02")
    assert result.__class__ is Allele, f'Expected parse("B*51:56:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:56:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_56_03():
    result = parse("B*51:56:03")
    assert result.__class__ is Allele, f'Expected parse("B*51:56:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:56:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_57():
    result = parse("B*51:57")
    assert result.__class__ is Allele, f'Expected parse("B*51:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_58():
    result = parse("B*51:58")
    assert result.__class__ is Allele, f'Expected parse("B*51:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_59():
    result = parse("B*51:59")
    assert result.__class__ is Allele, f'Expected parse("B*51:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_60():
    result = parse("B*51:60")
    assert result.__class__ is Allele, f'Expected parse("B*51:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_61_01():
    result = parse("B*51:61:01")
    assert result.__class__ is Allele, f'Expected parse("B*51:61:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:61:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_61_02():
    result = parse("B*51:61:02")
    assert result.__class__ is Allele, f'Expected parse("B*51:61:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:61:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_62():
    result = parse("B*51:62")
    assert result.__class__ is Allele, f'Expected parse("B*51:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_63_01():
    result = parse("B*51:63:01")
    assert result.__class__ is Allele, f'Expected parse("B*51:63:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:63:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_63_02():
    result = parse("B*51:63:02")
    assert result.__class__ is Allele, f'Expected parse("B*51:63:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:63:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_64():
    result = parse("B*51:64")
    assert result.__class__ is Allele, f'Expected parse("B*51:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_65():
    result = parse("B*51:65")
    assert result.__class__ is Allele, f'Expected parse("B*51:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_66():
    result = parse("B*51:66")
    assert result.__class__ is Allele, f'Expected parse("B*51:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_67():
    result = parse("B*51:67")
    assert result.__class__ is Allele, f'Expected parse("B*51:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_68():
    result = parse("B*51:68")
    assert result.__class__ is Allele, f'Expected parse("B*51:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_69():
    result = parse("B*51:69")
    assert result.__class__ is Allele, f'Expected parse("B*51:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_70():
    result = parse("B*51:70")
    assert result.__class__ is Allele, f'Expected parse("B*51:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_71():
    result = parse("B*51:71")
    assert result.__class__ is Allele, f'Expected parse("B*51:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_72():
    result = parse("B*51:72")
    assert result.__class__ is Allele, f'Expected parse("B*51:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_73():
    result = parse("B*51:73")
    assert result.__class__ is Allele, f'Expected parse("B*51:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_74():
    result = parse("B*51:74")
    assert result.__class__ is Allele, f'Expected parse("B*51:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_75():
    result = parse("B*51:75")
    assert result.__class__ is Allele, f'Expected parse("B*51:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_76():
    result = parse("B*51:76")
    assert result.__class__ is Allele, f'Expected parse("B*51:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_77():
    result = parse("B*51:77")
    assert result.__class__ is Allele, f'Expected parse("B*51:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_78_01():
    result = parse("B*51:78:01")
    assert result.__class__ is Allele, f'Expected parse("B*51:78:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:78:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_78_02():
    result = parse("B*51:78:02")
    assert result.__class__ is Allele, f'Expected parse("B*51:78:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:78:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_79():
    result = parse("B*51:79")
    assert result.__class__ is Allele, f'Expected parse("B*51:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_80():
    result = parse("B*51:80")
    assert result.__class__ is Allele, f'Expected parse("B*51:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_81():
    result = parse("B*51:81")
    assert result.__class__ is Allele, f'Expected parse("B*51:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_82():
    result = parse("B*51:82")
    assert result.__class__ is Allele, f'Expected parse("B*51:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_83():
    result = parse("B*51:83")
    assert result.__class__ is Allele, f'Expected parse("B*51:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_84():
    result = parse("B*51:84")
    assert result.__class__ is Allele, f'Expected parse("B*51:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_85():
    result = parse("B*51:85")
    assert result.__class__ is Allele, f'Expected parse("B*51:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_86():
    result = parse("B*51:86")
    assert result.__class__ is Allele, f'Expected parse("B*51:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_87():
    result = parse("B*51:87")
    assert result.__class__ is Allele, f'Expected parse("B*51:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_88():
    result = parse("B*51:88")
    assert result.__class__ is Allele, f'Expected parse("B*51:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_89():
    result = parse("B*51:89")
    assert result.__class__ is Allele, f'Expected parse("B*51:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_90():
    result = parse("B*51:90")
    assert result.__class__ is Allele, f'Expected parse("B*51:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_91():
    result = parse("B*51:91")
    assert result.__class__ is Allele, f'Expected parse("B*51:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_92_01():
    result = parse("B*51:92:01")
    assert result.__class__ is Allele, f'Expected parse("B*51:92:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:92:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_92_02():
    result = parse("B*51:92:02")
    assert result.__class__ is Allele, f'Expected parse("B*51:92:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*51:92:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_93():
    result = parse("B*51:93")
    assert result.__class__ is Allele, f'Expected parse("B*51:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_94():
    result = parse("B*51:94")
    assert result.__class__ is Allele, f'Expected parse("B*51:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_95():
    result = parse("B*51:95")
    assert result.__class__ is Allele, f'Expected parse("B*51:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_96():
    result = parse("B*51:96")
    assert result.__class__ is Allele, f'Expected parse("B*51:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_97():
    result = parse("B*51:97")
    assert result.__class__ is Allele, f'Expected parse("B*51:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_98N():
    result = parse("B*51:98N")
    assert result.__class__ is Allele, f'Expected parse("B*51:98N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:98N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_51_99():
    result = parse("B*51:99")
    assert result.__class__ is Allele, f'Expected parse("B*51:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*51:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_01_01():
    result = parse("B*52:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_01_02():
    result = parse("B*52:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_01_03():
    result = parse("B*52:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_01_04():
    result = parse("B*52:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_01_05():
    result = parse("B*52:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_01_06():
    result = parse("B*52:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_01_07():
    result = parse("B*52:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_01_08():
    result = parse("B*52:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_01_09():
    result = parse("B*52:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_01_10():
    result = parse("B*52:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_01_11():
    result = parse("B*52:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_01_12():
    result = parse("B*52:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_01_13():
    result = parse("B*52:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_01_14():
    result = parse("B*52:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_01_15():
    result = parse("B*52:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_01_16():
    result = parse("B*52:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_02_01():
    result = parse("B*52:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_02_02():
    result = parse("B*52:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_02_03():
    result = parse("B*52:01:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_02_04():
    result = parse("B*52:01:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_02_05():
    result = parse("B*52:01:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*52:01:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*52:01:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_03():
    result = parse("B*52:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_04():
    result = parse("B*52:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_05():
    result = parse("B*52:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_06():
    result = parse("B*52:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_07():
    result = parse("B*52:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_08():
    result = parse("B*52:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_09():
    result = parse("B*52:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_10():
    result = parse("B*52:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_11():
    result = parse("B*52:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_12():
    result = parse("B*52:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_13():
    result = parse("B*52:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_14():
    result = parse("B*52:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_15():
    result = parse("B*52:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_16():
    result = parse("B*52:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_17():
    result = parse("B*52:01:17")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_18():
    result = parse("B*52:01:18")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_19():
    result = parse("B*52:01:19")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_20():
    result = parse("B*52:01:20")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_21():
    result = parse("B*52:01:21")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_22():
    result = parse("B*52:01:22")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_23():
    result = parse("B*52:01:23")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_24():
    result = parse("B*52:01:24")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_25():
    result = parse("B*52:01:25")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_26():
    result = parse("B*52:01:26")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_27():
    result = parse("B*52:01:27")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_28():
    result = parse("B*52:01:28")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_29():
    result = parse("B*52:01:29")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_30():
    result = parse("B*52:01:30")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_31():
    result = parse("B*52:01:31")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_32():
    result = parse("B*52:01:32")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_33():
    result = parse("B*52:01:33")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_34():
    result = parse("B*52:01:34")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_35():
    result = parse("B*52:01:35")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_36():
    result = parse("B*52:01:36")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_37():
    result = parse("B*52:01:37")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_38():
    result = parse("B*52:01:38")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_39():
    result = parse("B*52:01:39")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_40():
    result = parse("B*52:01:40")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_41():
    result = parse("B*52:01:41")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_42():
    result = parse("B*52:01:42")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_43():
    result = parse("B*52:01:43")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_44():
    result = parse("B*52:01:44")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_45():
    result = parse("B*52:01:45")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_46():
    result = parse("B*52:01:46")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_47():
    result = parse("B*52:01:47")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_01_48():
    result = parse("B*52:01:48")
    assert result.__class__ is Allele, f'Expected parse("B*52:01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_02_01():
    result = parse("B*52:02:01")
    assert result.__class__ is Allele, f'Expected parse("B*52:02:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_02_02():
    result = parse("B*52:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*52:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_03():
    result = parse("B*52:03")
    assert result.__class__ is Allele, f'Expected parse("B*52:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_04():
    result = parse("B*52:04")
    assert result.__class__ is Allele, f'Expected parse("B*52:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_05():
    result = parse("B*52:05")
    assert result.__class__ is Allele, f'Expected parse("B*52:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_06_01():
    result = parse("B*52:06:01")
    assert result.__class__ is Allele, f'Expected parse("B*52:06:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_06_02():
    result = parse("B*52:06:02")
    assert result.__class__ is Allele, f'Expected parse("B*52:06:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_06_03():
    result = parse("B*52:06:03")
    assert result.__class__ is Allele, f'Expected parse("B*52:06:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:06:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_07():
    result = parse("B*52:07")
    assert result.__class__ is Allele, f'Expected parse("B*52:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_08():
    result = parse("B*52:08")
    assert result.__class__ is Allele, f'Expected parse("B*52:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_09_01():
    result = parse("B*52:09:01")
    assert result.__class__ is Allele, f'Expected parse("B*52:09:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:09:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_09_02():
    result = parse("B*52:09:02")
    assert result.__class__ is Allele, f'Expected parse("B*52:09:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:09:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_100():
    result = parse("B*52:100")
    assert result.__class__ is Allele, f'Expected parse("B*52:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_10_01():
    result = parse("B*52:10:01")
    assert result.__class__ is Allele, f'Expected parse("B*52:10:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:10:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_10_02():
    result = parse("B*52:10:02")
    assert result.__class__ is Allele, f'Expected parse("B*52:10:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:10:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_10_03():
    result = parse("B*52:10:03")
    assert result.__class__ is Allele, f'Expected parse("B*52:10:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:10:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_11():
    result = parse("B*52:11")
    assert result.__class__ is Allele, f'Expected parse("B*52:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_12():
    result = parse("B*52:12")
    assert result.__class__ is Allele, f'Expected parse("B*52:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_13():
    result = parse("B*52:13")
    assert result.__class__ is Allele, f'Expected parse("B*52:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_14_01():
    result = parse("B*52:14:01")
    assert result.__class__ is Allele, f'Expected parse("B*52:14:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:14:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_14_02():
    result = parse("B*52:14:02")
    assert result.__class__ is Allele, f'Expected parse("B*52:14:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:14:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_15():
    result = parse("B*52:15")
    assert result.__class__ is Allele, f'Expected parse("B*52:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_16():
    result = parse("B*52:16")
    assert result.__class__ is Allele, f'Expected parse("B*52:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_17():
    result = parse("B*52:17")
    assert result.__class__ is Allele, f'Expected parse("B*52:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_18():
    result = parse("B*52:18")
    assert result.__class__ is Allele, f'Expected parse("B*52:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_19():
    result = parse("B*52:19")
    assert result.__class__ is Allele, f'Expected parse("B*52:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_20():
    result = parse("B*52:20")
    assert result.__class__ is Allele, f'Expected parse("B*52:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_21_01():
    result = parse("B*52:21:01")
    assert result.__class__ is Allele, f'Expected parse("B*52:21:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:21:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_21_02():
    result = parse("B*52:21:02")
    assert result.__class__ is Allele, f'Expected parse("B*52:21:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:21:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_22():
    result = parse("B*52:22")
    assert result.__class__ is Allele, f'Expected parse("B*52:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_23():
    result = parse("B*52:23")
    assert result.__class__ is Allele, f'Expected parse("B*52:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_24():
    result = parse("B*52:24")
    assert result.__class__ is Allele, f'Expected parse("B*52:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_25_01():
    result = parse("B*52:25:01")
    assert result.__class__ is Allele, f'Expected parse("B*52:25:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:25:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_25_02():
    result = parse("B*52:25:02")
    assert result.__class__ is Allele, f'Expected parse("B*52:25:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:25:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_26():
    result = parse("B*52:26")
    assert result.__class__ is Allele, f'Expected parse("B*52:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_27():
    result = parse("B*52:27")
    assert result.__class__ is Allele, f'Expected parse("B*52:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_28():
    result = parse("B*52:28")
    assert result.__class__ is Allele, f'Expected parse("B*52:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_29():
    result = parse("B*52:29")
    assert result.__class__ is Allele, f'Expected parse("B*52:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_30():
    result = parse("B*52:30")
    assert result.__class__ is Allele, f'Expected parse("B*52:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_31_01():
    result = parse("B*52:31:01")
    assert result.__class__ is Allele, f'Expected parse("B*52:31:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:31:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_31_02():
    result = parse("B*52:31:02")
    assert result.__class__ is Allele, f'Expected parse("B*52:31:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*52:31:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_32():
    result = parse("B*52:32")
    assert result.__class__ is Allele, f'Expected parse("B*52:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_33():
    result = parse("B*52:33")
    assert result.__class__ is Allele, f'Expected parse("B*52:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_34():
    result = parse("B*52:34")
    assert result.__class__ is Allele, f'Expected parse("B*52:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_35():
    result = parse("B*52:35")
    assert result.__class__ is Allele, f'Expected parse("B*52:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_36():
    result = parse("B*52:36")
    assert result.__class__ is Allele, f'Expected parse("B*52:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_37():
    result = parse("B*52:37")
    assert result.__class__ is Allele, f'Expected parse("B*52:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_38():
    result = parse("B*52:38")
    assert result.__class__ is Allele, f'Expected parse("B*52:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_39():
    result = parse("B*52:39")
    assert result.__class__ is Allele, f'Expected parse("B*52:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_40():
    result = parse("B*52:40")
    assert result.__class__ is Allele, f'Expected parse("B*52:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_41():
    result = parse("B*52:41")
    assert result.__class__ is Allele, f'Expected parse("B*52:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_42():
    result = parse("B*52:42")
    assert result.__class__ is Allele, f'Expected parse("B*52:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_43():
    result = parse("B*52:43")
    assert result.__class__ is Allele, f'Expected parse("B*52:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_44():
    result = parse("B*52:44")
    assert result.__class__ is Allele, f'Expected parse("B*52:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_45():
    result = parse("B*52:45")
    assert result.__class__ is Allele, f'Expected parse("B*52:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_46():
    result = parse("B*52:46")
    assert result.__class__ is Allele, f'Expected parse("B*52:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_47():
    result = parse("B*52:47")
    assert result.__class__ is Allele, f'Expected parse("B*52:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_48():
    result = parse("B*52:48")
    assert result.__class__ is Allele, f'Expected parse("B*52:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_49N():
    result = parse("B*52:49N")
    assert result.__class__ is Allele, f'Expected parse("B*52:49N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:49N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_50():
    result = parse("B*52:50")
    assert result.__class__ is Allele, f'Expected parse("B*52:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_51():
    result = parse("B*52:51")
    assert result.__class__ is Allele, f'Expected parse("B*52:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_52():
    result = parse("B*52:52")
    assert result.__class__ is Allele, f'Expected parse("B*52:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_53():
    result = parse("B*52:53")
    assert result.__class__ is Allele, f'Expected parse("B*52:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_54():
    result = parse("B*52:54")
    assert result.__class__ is Allele, f'Expected parse("B*52:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_55():
    result = parse("B*52:55")
    assert result.__class__ is Allele, f'Expected parse("B*52:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_56():
    result = parse("B*52:56")
    assert result.__class__ is Allele, f'Expected parse("B*52:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_57():
    result = parse("B*52:57")
    assert result.__class__ is Allele, f'Expected parse("B*52:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_58():
    result = parse("B*52:58")
    assert result.__class__ is Allele, f'Expected parse("B*52:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_59():
    result = parse("B*52:59")
    assert result.__class__ is Allele, f'Expected parse("B*52:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_60():
    result = parse("B*52:60")
    assert result.__class__ is Allele, f'Expected parse("B*52:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_61():
    result = parse("B*52:61")
    assert result.__class__ is Allele, f'Expected parse("B*52:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_62():
    result = parse("B*52:62")
    assert result.__class__ is Allele, f'Expected parse("B*52:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_63():
    result = parse("B*52:63")
    assert result.__class__ is Allele, f'Expected parse("B*52:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_64():
    result = parse("B*52:64")
    assert result.__class__ is Allele, f'Expected parse("B*52:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_65():
    result = parse("B*52:65")
    assert result.__class__ is Allele, f'Expected parse("B*52:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_66():
    result = parse("B*52:66")
    assert result.__class__ is Allele, f'Expected parse("B*52:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_67():
    result = parse("B*52:67")
    assert result.__class__ is Allele, f'Expected parse("B*52:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_68():
    result = parse("B*52:68")
    assert result.__class__ is Allele, f'Expected parse("B*52:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_69():
    result = parse("B*52:69")
    assert result.__class__ is Allele, f'Expected parse("B*52:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_70():
    result = parse("B*52:70")
    assert result.__class__ is Allele, f'Expected parse("B*52:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_71():
    result = parse("B*52:71")
    assert result.__class__ is Allele, f'Expected parse("B*52:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_72():
    result = parse("B*52:72")
    assert result.__class__ is Allele, f'Expected parse("B*52:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_73():
    result = parse("B*52:73")
    assert result.__class__ is Allele, f'Expected parse("B*52:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_74():
    result = parse("B*52:74")
    assert result.__class__ is Allele, f'Expected parse("B*52:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_75():
    result = parse("B*52:75")
    assert result.__class__ is Allele, f'Expected parse("B*52:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_76():
    result = parse("B*52:76")
    assert result.__class__ is Allele, f'Expected parse("B*52:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_77():
    result = parse("B*52:77")
    assert result.__class__ is Allele, f'Expected parse("B*52:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_78():
    result = parse("B*52:78")
    assert result.__class__ is Allele, f'Expected parse("B*52:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_79():
    result = parse("B*52:79")
    assert result.__class__ is Allele, f'Expected parse("B*52:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_80():
    result = parse("B*52:80")
    assert result.__class__ is Allele, f'Expected parse("B*52:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_81():
    result = parse("B*52:81")
    assert result.__class__ is Allele, f'Expected parse("B*52:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_82():
    result = parse("B*52:82")
    assert result.__class__ is Allele, f'Expected parse("B*52:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_83():
    result = parse("B*52:83")
    assert result.__class__ is Allele, f'Expected parse("B*52:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_84():
    result = parse("B*52:84")
    assert result.__class__ is Allele, f'Expected parse("B*52:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_85():
    result = parse("B*52:85")
    assert result.__class__ is Allele, f'Expected parse("B*52:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_86():
    result = parse("B*52:86")
    assert result.__class__ is Allele, f'Expected parse("B*52:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_87():
    result = parse("B*52:87")
    assert result.__class__ is Allele, f'Expected parse("B*52:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_88():
    result = parse("B*52:88")
    assert result.__class__ is Allele, f'Expected parse("B*52:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_89N():
    result = parse("B*52:89N")
    assert result.__class__ is Allele, f'Expected parse("B*52:89N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:89N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_90():
    result = parse("B*52:90")
    assert result.__class__ is Allele, f'Expected parse("B*52:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_91():
    result = parse("B*52:91")
    assert result.__class__ is Allele, f'Expected parse("B*52:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_92():
    result = parse("B*52:92")
    assert result.__class__ is Allele, f'Expected parse("B*52:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_93():
    result = parse("B*52:93")
    assert result.__class__ is Allele, f'Expected parse("B*52:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_94N():
    result = parse("B*52:94N")
    assert result.__class__ is Allele, f'Expected parse("B*52:94N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:94N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_95():
    result = parse("B*52:95")
    assert result.__class__ is Allele, f'Expected parse("B*52:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_96N():
    result = parse("B*52:96N")
    assert result.__class__ is Allele, f'Expected parse("B*52:96N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:96N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_97():
    result = parse("B*52:97")
    assert result.__class__ is Allele, f'Expected parse("B*52:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_98():
    result = parse("B*52:98")
    assert result.__class__ is Allele, f'Expected parse("B*52:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_52_99():
    result = parse("B*52:99")
    assert result.__class__ is Allele, f'Expected parse("B*52:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*52:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_01_01():
    result = parse("B*53:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*53:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*53:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_01_02():
    result = parse("B*53:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*53:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*53:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_01_03():
    result = parse("B*53:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*53:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*53:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_01_04():
    result = parse("B*53:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*53:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*53:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_01_05():
    result = parse("B*53:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*53:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*53:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_01_06():
    result = parse("B*53:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*53:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*53:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_01_07():
    result = parse("B*53:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*53:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*53:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_01_08():
    result = parse("B*53:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*53:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*53:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_01_09():
    result = parse("B*53:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*53:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*53:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_01_10():
    result = parse("B*53:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*53:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*53:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_02():
    result = parse("B*53:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_03():
    result = parse("B*53:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_04():
    result = parse("B*53:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_05():
    result = parse("B*53:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_06():
    result = parse("B*53:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_07():
    result = parse("B*53:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_08():
    result = parse("B*53:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_09():
    result = parse("B*53:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_10():
    result = parse("B*53:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_11():
    result = parse("B*53:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_12():
    result = parse("B*53:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_13():
    result = parse("B*53:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_14():
    result = parse("B*53:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_15():
    result = parse("B*53:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_16():
    result = parse("B*53:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_17():
    result = parse("B*53:01:17")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_18():
    result = parse("B*53:01:18")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_19():
    result = parse("B*53:01:19")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_20():
    result = parse("B*53:01:20")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_21():
    result = parse("B*53:01:21")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_22():
    result = parse("B*53:01:22")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_23():
    result = parse("B*53:01:23")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_24():
    result = parse("B*53:01:24")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_01_25():
    result = parse("B*53:01:25")
    assert result.__class__ is Allele, f'Expected parse("B*53:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_02():
    result = parse("B*53:02")
    assert result.__class__ is Allele, f'Expected parse("B*53:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_03():
    result = parse("B*53:03")
    assert result.__class__ is Allele, f'Expected parse("B*53:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_04():
    result = parse("B*53:04")
    assert result.__class__ is Allele, f'Expected parse("B*53:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_05_01():
    result = parse("B*53:05:01")
    assert result.__class__ is Allele, f'Expected parse("B*53:05:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_05_02():
    result = parse("B*53:05:02")
    assert result.__class__ is Allele, f'Expected parse("B*53:05:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_06():
    result = parse("B*53:06")
    assert result.__class__ is Allele, f'Expected parse("B*53:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_07():
    result = parse("B*53:07")
    assert result.__class__ is Allele, f'Expected parse("B*53:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_08_01():
    result = parse("B*53:08:01")
    assert result.__class__ is Allele, f'Expected parse("B*53:08:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:08:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_08_02():
    result = parse("B*53:08:02")
    assert result.__class__ is Allele, f'Expected parse("B*53:08:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:08:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_09():
    result = parse("B*53:09")
    assert result.__class__ is Allele, f'Expected parse("B*53:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_10():
    result = parse("B*53:10")
    assert result.__class__ is Allele, f'Expected parse("B*53:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_11():
    result = parse("B*53:11")
    assert result.__class__ is Allele, f'Expected parse("B*53:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_12():
    result = parse("B*53:12")
    assert result.__class__ is Allele, f'Expected parse("B*53:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_13():
    result = parse("B*53:13")
    assert result.__class__ is Allele, f'Expected parse("B*53:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_14():
    result = parse("B*53:14")
    assert result.__class__ is Allele, f'Expected parse("B*53:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_15():
    result = parse("B*53:15")
    assert result.__class__ is Allele, f'Expected parse("B*53:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_16():
    result = parse("B*53:16")
    assert result.__class__ is Allele, f'Expected parse("B*53:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_17_01():
    result = parse("B*53:17:01")
    assert result.__class__ is Allele, f'Expected parse("B*53:17:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:17:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_17_02():
    result = parse("B*53:17:02")
    assert result.__class__ is Allele, f'Expected parse("B*53:17:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:17:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_18():
    result = parse("B*53:18")
    assert result.__class__ is Allele, f'Expected parse("B*53:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_19():
    result = parse("B*53:19")
    assert result.__class__ is Allele, f'Expected parse("B*53:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_20():
    result = parse("B*53:20")
    assert result.__class__ is Allele, f'Expected parse("B*53:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_21():
    result = parse("B*53:21")
    assert result.__class__ is Allele, f'Expected parse("B*53:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_22():
    result = parse("B*53:22")
    assert result.__class__ is Allele, f'Expected parse("B*53:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_23():
    result = parse("B*53:23")
    assert result.__class__ is Allele, f'Expected parse("B*53:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_24():
    result = parse("B*53:24")
    assert result.__class__ is Allele, f'Expected parse("B*53:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_25():
    result = parse("B*53:25")
    assert result.__class__ is Allele, f'Expected parse("B*53:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_26():
    result = parse("B*53:26")
    assert result.__class__ is Allele, f'Expected parse("B*53:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_27():
    result = parse("B*53:27")
    assert result.__class__ is Allele, f'Expected parse("B*53:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_28():
    result = parse("B*53:28")
    assert result.__class__ is Allele, f'Expected parse("B*53:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_29():
    result = parse("B*53:29")
    assert result.__class__ is Allele, f'Expected parse("B*53:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_30():
    result = parse("B*53:30")
    assert result.__class__ is Allele, f'Expected parse("B*53:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_31():
    result = parse("B*53:31")
    assert result.__class__ is Allele, f'Expected parse("B*53:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_32():
    result = parse("B*53:32")
    assert result.__class__ is Allele, f'Expected parse("B*53:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_33():
    result = parse("B*53:33")
    assert result.__class__ is Allele, f'Expected parse("B*53:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_34():
    result = parse("B*53:34")
    assert result.__class__ is Allele, f'Expected parse("B*53:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_35():
    result = parse("B*53:35")
    assert result.__class__ is Allele, f'Expected parse("B*53:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_36():
    result = parse("B*53:36")
    assert result.__class__ is Allele, f'Expected parse("B*53:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_37():
    result = parse("B*53:37")
    assert result.__class__ is Allele, f'Expected parse("B*53:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_38():
    result = parse("B*53:38")
    assert result.__class__ is Allele, f'Expected parse("B*53:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_39():
    result = parse("B*53:39")
    assert result.__class__ is Allele, f'Expected parse("B*53:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_40():
    result = parse("B*53:40")
    assert result.__class__ is Allele, f'Expected parse("B*53:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_41():
    result = parse("B*53:41")
    assert result.__class__ is Allele, f'Expected parse("B*53:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_42():
    result = parse("B*53:42")
    assert result.__class__ is Allele, f'Expected parse("B*53:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_43_01():
    result = parse("B*53:43:01")
    assert result.__class__ is Allele, f'Expected parse("B*53:43:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:43:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_43_02():
    result = parse("B*53:43:02")
    assert result.__class__ is Allele, f'Expected parse("B*53:43:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*53:43:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_44():
    result = parse("B*53:44")
    assert result.__class__ is Allele, f'Expected parse("B*53:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_45():
    result = parse("B*53:45")
    assert result.__class__ is Allele, f'Expected parse("B*53:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_46():
    result = parse("B*53:46")
    assert result.__class__ is Allele, f'Expected parse("B*53:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_47():
    result = parse("B*53:47")
    assert result.__class__ is Allele, f'Expected parse("B*53:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_48N():
    result = parse("B*53:48N")
    assert result.__class__ is Allele, f'Expected parse("B*53:48N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:48N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_49():
    result = parse("B*53:49")
    assert result.__class__ is Allele, f'Expected parse("B*53:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_50():
    result = parse("B*53:50")
    assert result.__class__ is Allele, f'Expected parse("B*53:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_51():
    result = parse("B*53:51")
    assert result.__class__ is Allele, f'Expected parse("B*53:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_52():
    result = parse("B*53:52")
    assert result.__class__ is Allele, f'Expected parse("B*53:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_53():
    result = parse("B*53:53")
    assert result.__class__ is Allele, f'Expected parse("B*53:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_54():
    result = parse("B*53:54")
    assert result.__class__ is Allele, f'Expected parse("B*53:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_55():
    result = parse("B*53:55")
    assert result.__class__ is Allele, f'Expected parse("B*53:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_56():
    result = parse("B*53:56")
    assert result.__class__ is Allele, f'Expected parse("B*53:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_57():
    result = parse("B*53:57")
    assert result.__class__ is Allele, f'Expected parse("B*53:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_58():
    result = parse("B*53:58")
    assert result.__class__ is Allele, f'Expected parse("B*53:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_59():
    result = parse("B*53:59")
    assert result.__class__ is Allele, f'Expected parse("B*53:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_60():
    result = parse("B*53:60")
    assert result.__class__ is Allele, f'Expected parse("B*53:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_61():
    result = parse("B*53:61")
    assert result.__class__ is Allele, f'Expected parse("B*53:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_53_62():
    result = parse("B*53:62")
    assert result.__class__ is Allele, f'Expected parse("B*53:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*53:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_01_01_01():
    result = parse("B*54:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*54:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*54:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_01_01_02():
    result = parse("B*54:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*54:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*54:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_01_02():
    result = parse("B*54:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*54:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*54:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_01_03():
    result = parse("B*54:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*54:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*54:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_01_04():
    result = parse("B*54:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*54:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*54:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_01_05():
    result = parse("B*54:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*54:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*54:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_01_06():
    result = parse("B*54:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*54:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*54:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_01_07():
    result = parse("B*54:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*54:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*54:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_01_08():
    result = parse("B*54:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*54:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*54:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_01_09():
    result = parse("B*54:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*54:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*54:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_02():
    result = parse("B*54:02")
    assert result.__class__ is Allele, f'Expected parse("B*54:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_03():
    result = parse("B*54:03")
    assert result.__class__ is Allele, f'Expected parse("B*54:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_04():
    result = parse("B*54:04")
    assert result.__class__ is Allele, f'Expected parse("B*54:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_05N():
    result = parse("B*54:05N")
    assert result.__class__ is Allele, f'Expected parse("B*54:05N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:05N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_06():
    result = parse("B*54:06")
    assert result.__class__ is Allele, f'Expected parse("B*54:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_07():
    result = parse("B*54:07")
    assert result.__class__ is Allele, f'Expected parse("B*54:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_08N():
    result = parse("B*54:08N")
    assert result.__class__ is Allele, f'Expected parse("B*54:08N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:08N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_09():
    result = parse("B*54:09")
    assert result.__class__ is Allele, f'Expected parse("B*54:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_10():
    result = parse("B*54:10")
    assert result.__class__ is Allele, f'Expected parse("B*54:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_11():
    result = parse("B*54:11")
    assert result.__class__ is Allele, f'Expected parse("B*54:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_12():
    result = parse("B*54:12")
    assert result.__class__ is Allele, f'Expected parse("B*54:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_13():
    result = parse("B*54:13")
    assert result.__class__ is Allele, f'Expected parse("B*54:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_14():
    result = parse("B*54:14")
    assert result.__class__ is Allele, f'Expected parse("B*54:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_15():
    result = parse("B*54:15")
    assert result.__class__ is Allele, f'Expected parse("B*54:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_16():
    result = parse("B*54:16")
    assert result.__class__ is Allele, f'Expected parse("B*54:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_17():
    result = parse("B*54:17")
    assert result.__class__ is Allele, f'Expected parse("B*54:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_18():
    result = parse("B*54:18")
    assert result.__class__ is Allele, f'Expected parse("B*54:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_19():
    result = parse("B*54:19")
    assert result.__class__ is Allele, f'Expected parse("B*54:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_20():
    result = parse("B*54:20")
    assert result.__class__ is Allele, f'Expected parse("B*54:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_21():
    result = parse("B*54:21")
    assert result.__class__ is Allele, f'Expected parse("B*54:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_22():
    result = parse("B*54:22")
    assert result.__class__ is Allele, f'Expected parse("B*54:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_23():
    result = parse("B*54:23")
    assert result.__class__ is Allele, f'Expected parse("B*54:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_24():
    result = parse("B*54:24")
    assert result.__class__ is Allele, f'Expected parse("B*54:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_25():
    result = parse("B*54:25")
    assert result.__class__ is Allele, f'Expected parse("B*54:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_26():
    result = parse("B*54:26")
    assert result.__class__ is Allele, f'Expected parse("B*54:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_27():
    result = parse("B*54:27")
    assert result.__class__ is Allele, f'Expected parse("B*54:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_28():
    result = parse("B*54:28")
    assert result.__class__ is Allele, f'Expected parse("B*54:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_29():
    result = parse("B*54:29")
    assert result.__class__ is Allele, f'Expected parse("B*54:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_30():
    result = parse("B*54:30")
    assert result.__class__ is Allele, f'Expected parse("B*54:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_31():
    result = parse("B*54:31")
    assert result.__class__ is Allele, f'Expected parse("B*54:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_32():
    result = parse("B*54:32")
    assert result.__class__ is Allele, f'Expected parse("B*54:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_33():
    result = parse("B*54:33")
    assert result.__class__ is Allele, f'Expected parse("B*54:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_34():
    result = parse("B*54:34")
    assert result.__class__ is Allele, f'Expected parse("B*54:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_35():
    result = parse("B*54:35")
    assert result.__class__ is Allele, f'Expected parse("B*54:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_36():
    result = parse("B*54:36")
    assert result.__class__ is Allele, f'Expected parse("B*54:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_37():
    result = parse("B*54:37")
    assert result.__class__ is Allele, f'Expected parse("B*54:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_38():
    result = parse("B*54:38")
    assert result.__class__ is Allele, f'Expected parse("B*54:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_39():
    result = parse("B*54:39")
    assert result.__class__ is Allele, f'Expected parse("B*54:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_40():
    result = parse("B*54:40")
    assert result.__class__ is Allele, f'Expected parse("B*54:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_54_41():
    result = parse("B*54:41")
    assert result.__class__ is Allele, f'Expected parse("B*54:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*54:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_01():
    result = parse("B*55:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_02():
    result = parse("B*55:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_03():
    result = parse("B*55:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_04():
    result = parse("B*55:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_05():
    result = parse("B*55:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_06():
    result = parse("B*55:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_07():
    result = parse("B*55:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_08():
    result = parse("B*55:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_09():
    result = parse("B*55:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_10():
    result = parse("B*55:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_11():
    result = parse("B*55:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_12():
    result = parse("B*55:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_13():
    result = parse("B*55:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_14():
    result = parse("B*55:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_15():
    result = parse("B*55:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_16():
    result = parse("B*55:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_17():
    result = parse("B*55:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_18():
    result = parse("B*55:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_01_19():
    result = parse("B*55:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_02():
    result = parse("B*55:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_03():
    result = parse("B*55:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_04():
    result = parse("B*55:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_05():
    result = parse("B*55:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_06():
    result = parse("B*55:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_07():
    result = parse("B*55:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_08():
    result = parse("B*55:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_09():
    result = parse("B*55:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_10():
    result = parse("B*55:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_11():
    result = parse("B*55:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_12():
    result = parse("B*55:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_13():
    result = parse("B*55:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_14():
    result = parse("B*55:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_15():
    result = parse("B*55:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_16():
    result = parse("B*55:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_17():
    result = parse("B*55:01:17")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_18():
    result = parse("B*55:01:18")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_19():
    result = parse("B*55:01:19")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_20():
    result = parse("B*55:01:20")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_21():
    result = parse("B*55:01:21")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_22():
    result = parse("B*55:01:22")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_23():
    result = parse("B*55:01:23")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_24():
    result = parse("B*55:01:24")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_25():
    result = parse("B*55:01:25")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_01_26():
    result = parse("B*55:01:26")
    assert result.__class__ is Allele, f'Expected parse("B*55:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_01_01():
    result = parse("B*55:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_01_02():
    result = parse("B*55:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_01_03():
    result = parse("B*55:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_01_04():
    result = parse("B*55:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_01_05():
    result = parse("B*55:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_01_06():
    result = parse("B*55:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*55:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*55:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_02():
    result = parse("B*55:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*55:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_03():
    result = parse("B*55:02:03")
    assert result.__class__ is Allele, f'Expected parse("B*55:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_04():
    result = parse("B*55:02:04")
    assert result.__class__ is Allele, f'Expected parse("B*55:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_05():
    result = parse("B*55:02:05")
    assert result.__class__ is Allele, f'Expected parse("B*55:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_06():
    result = parse("B*55:02:06")
    assert result.__class__ is Allele, f'Expected parse("B*55:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_07():
    result = parse("B*55:02:07")
    assert result.__class__ is Allele, f'Expected parse("B*55:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_08():
    result = parse("B*55:02:08")
    assert result.__class__ is Allele, f'Expected parse("B*55:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_09():
    result = parse("B*55:02:09")
    assert result.__class__ is Allele, f'Expected parse("B*55:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_10():
    result = parse("B*55:02:10")
    assert result.__class__ is Allele, f'Expected parse("B*55:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_11():
    result = parse("B*55:02:11")
    assert result.__class__ is Allele, f'Expected parse("B*55:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_12():
    result = parse("B*55:02:12")
    assert result.__class__ is Allele, f'Expected parse("B*55:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_13():
    result = parse("B*55:02:13")
    assert result.__class__ is Allele, f'Expected parse("B*55:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_14():
    result = parse("B*55:02:14")
    assert result.__class__ is Allele, f'Expected parse("B*55:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_02_15():
    result = parse("B*55:02:15")
    assert result.__class__ is Allele, f'Expected parse("B*55:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_03():
    result = parse("B*55:03")
    assert result.__class__ is Allele, f'Expected parse("B*55:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_04():
    result = parse("B*55:04")
    assert result.__class__ is Allele, f'Expected parse("B*55:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_05():
    result = parse("B*55:05")
    assert result.__class__ is Allele, f'Expected parse("B*55:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_07():
    result = parse("B*55:07")
    assert result.__class__ is Allele, f'Expected parse("B*55:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_08():
    result = parse("B*55:08")
    assert result.__class__ is Allele, f'Expected parse("B*55:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_09():
    result = parse("B*55:09")
    assert result.__class__ is Allele, f'Expected parse("B*55:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_10():
    result = parse("B*55:10")
    assert result.__class__ is Allele, f'Expected parse("B*55:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_100():
    result = parse("B*55:100")
    assert result.__class__ is Allele, f'Expected parse("B*55:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_101():
    result = parse("B*55:101")
    assert result.__class__ is Allele, f'Expected parse("B*55:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_102():
    result = parse("B*55:102")
    assert result.__class__ is Allele, f'Expected parse("B*55:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_103():
    result = parse("B*55:103")
    assert result.__class__ is Allele, f'Expected parse("B*55:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_104():
    result = parse("B*55:104")
    assert result.__class__ is Allele, f'Expected parse("B*55:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_105():
    result = parse("B*55:105")
    assert result.__class__ is Allele, f'Expected parse("B*55:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_106():
    result = parse("B*55:106")
    assert result.__class__ is Allele, f'Expected parse("B*55:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_107():
    result = parse("B*55:107")
    assert result.__class__ is Allele, f'Expected parse("B*55:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_108():
    result = parse("B*55:108")
    assert result.__class__ is Allele, f'Expected parse("B*55:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_109():
    result = parse("B*55:109")
    assert result.__class__ is Allele, f'Expected parse("B*55:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_11():
    result = parse("B*55:11")
    assert result.__class__ is Allele, f'Expected parse("B*55:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_12():
    result = parse("B*55:12")
    assert result.__class__ is Allele, f'Expected parse("B*55:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_13():
    result = parse("B*55:13")
    assert result.__class__ is Allele, f'Expected parse("B*55:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_14():
    result = parse("B*55:14")
    assert result.__class__ is Allele, f'Expected parse("B*55:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_15():
    result = parse("B*55:15")
    assert result.__class__ is Allele, f'Expected parse("B*55:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_16():
    result = parse("B*55:16")
    assert result.__class__ is Allele, f'Expected parse("B*55:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_17():
    result = parse("B*55:17")
    assert result.__class__ is Allele, f'Expected parse("B*55:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_18():
    result = parse("B*55:18")
    assert result.__class__ is Allele, f'Expected parse("B*55:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_19():
    result = parse("B*55:19")
    assert result.__class__ is Allele, f'Expected parse("B*55:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_20():
    result = parse("B*55:20")
    assert result.__class__ is Allele, f'Expected parse("B*55:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_21():
    result = parse("B*55:21")
    assert result.__class__ is Allele, f'Expected parse("B*55:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_22():
    result = parse("B*55:22")
    assert result.__class__ is Allele, f'Expected parse("B*55:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_23():
    result = parse("B*55:23")
    assert result.__class__ is Allele, f'Expected parse("B*55:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_24():
    result = parse("B*55:24")
    assert result.__class__ is Allele, f'Expected parse("B*55:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_25():
    result = parse("B*55:25")
    assert result.__class__ is Allele, f'Expected parse("B*55:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_26():
    result = parse("B*55:26")
    assert result.__class__ is Allele, f'Expected parse("B*55:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_27():
    result = parse("B*55:27")
    assert result.__class__ is Allele, f'Expected parse("B*55:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_28_01():
    result = parse("B*55:28:01")
    assert result.__class__ is Allele, f'Expected parse("B*55:28:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:28:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_28_02():
    result = parse("B*55:28:02")
    assert result.__class__ is Allele, f'Expected parse("B*55:28:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*55:28:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_29():
    result = parse("B*55:29")
    assert result.__class__ is Allele, f'Expected parse("B*55:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_30():
    result = parse("B*55:30")
    assert result.__class__ is Allele, f'Expected parse("B*55:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_31():
    result = parse("B*55:31")
    assert result.__class__ is Allele, f'Expected parse("B*55:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_32():
    result = parse("B*55:32")
    assert result.__class__ is Allele, f'Expected parse("B*55:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_33():
    result = parse("B*55:33")
    assert result.__class__ is Allele, f'Expected parse("B*55:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_34():
    result = parse("B*55:34")
    assert result.__class__ is Allele, f'Expected parse("B*55:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_35():
    result = parse("B*55:35")
    assert result.__class__ is Allele, f'Expected parse("B*55:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_36():
    result = parse("B*55:36")
    assert result.__class__ is Allele, f'Expected parse("B*55:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_37():
    result = parse("B*55:37")
    assert result.__class__ is Allele, f'Expected parse("B*55:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_38():
    result = parse("B*55:38")
    assert result.__class__ is Allele, f'Expected parse("B*55:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_39():
    result = parse("B*55:39")
    assert result.__class__ is Allele, f'Expected parse("B*55:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_40():
    result = parse("B*55:40")
    assert result.__class__ is Allele, f'Expected parse("B*55:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_41():
    result = parse("B*55:41")
    assert result.__class__ is Allele, f'Expected parse("B*55:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_42():
    result = parse("B*55:42")
    assert result.__class__ is Allele, f'Expected parse("B*55:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_43():
    result = parse("B*55:43")
    assert result.__class__ is Allele, f'Expected parse("B*55:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_44():
    result = parse("B*55:44")
    assert result.__class__ is Allele, f'Expected parse("B*55:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_45():
    result = parse("B*55:45")
    assert result.__class__ is Allele, f'Expected parse("B*55:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_46():
    result = parse("B*55:46")
    assert result.__class__ is Allele, f'Expected parse("B*55:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_47():
    result = parse("B*55:47")
    assert result.__class__ is Allele, f'Expected parse("B*55:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_48():
    result = parse("B*55:48")
    assert result.__class__ is Allele, f'Expected parse("B*55:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_49():
    result = parse("B*55:49")
    assert result.__class__ is Allele, f'Expected parse("B*55:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_50():
    result = parse("B*55:50")
    assert result.__class__ is Allele, f'Expected parse("B*55:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_51():
    result = parse("B*55:51")
    assert result.__class__ is Allele, f'Expected parse("B*55:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_52():
    result = parse("B*55:52")
    assert result.__class__ is Allele, f'Expected parse("B*55:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_53():
    result = parse("B*55:53")
    assert result.__class__ is Allele, f'Expected parse("B*55:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_54():
    result = parse("B*55:54")
    assert result.__class__ is Allele, f'Expected parse("B*55:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_55N():
    result = parse("B*55:55N")
    assert result.__class__ is Allele, f'Expected parse("B*55:55N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:55N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_56():
    result = parse("B*55:56")
    assert result.__class__ is Allele, f'Expected parse("B*55:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_57():
    result = parse("B*55:57")
    assert result.__class__ is Allele, f'Expected parse("B*55:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_58():
    result = parse("B*55:58")
    assert result.__class__ is Allele, f'Expected parse("B*55:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_59():
    result = parse("B*55:59")
    assert result.__class__ is Allele, f'Expected parse("B*55:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_60():
    result = parse("B*55:60")
    assert result.__class__ is Allele, f'Expected parse("B*55:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_61():
    result = parse("B*55:61")
    assert result.__class__ is Allele, f'Expected parse("B*55:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_62():
    result = parse("B*55:62")
    assert result.__class__ is Allele, f'Expected parse("B*55:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_63():
    result = parse("B*55:63")
    assert result.__class__ is Allele, f'Expected parse("B*55:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_64():
    result = parse("B*55:64")
    assert result.__class__ is Allele, f'Expected parse("B*55:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_65():
    result = parse("B*55:65")
    assert result.__class__ is Allele, f'Expected parse("B*55:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_66():
    result = parse("B*55:66")
    assert result.__class__ is Allele, f'Expected parse("B*55:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_67():
    result = parse("B*55:67")
    assert result.__class__ is Allele, f'Expected parse("B*55:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_68():
    result = parse("B*55:68")
    assert result.__class__ is Allele, f'Expected parse("B*55:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_69():
    result = parse("B*55:69")
    assert result.__class__ is Allele, f'Expected parse("B*55:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_70():
    result = parse("B*55:70")
    assert result.__class__ is Allele, f'Expected parse("B*55:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_71():
    result = parse("B*55:71")
    assert result.__class__ is Allele, f'Expected parse("B*55:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_72():
    result = parse("B*55:72")
    assert result.__class__ is Allele, f'Expected parse("B*55:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_73():
    result = parse("B*55:73")
    assert result.__class__ is Allele, f'Expected parse("B*55:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_74():
    result = parse("B*55:74")
    assert result.__class__ is Allele, f'Expected parse("B*55:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_75():
    result = parse("B*55:75")
    assert result.__class__ is Allele, f'Expected parse("B*55:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_76():
    result = parse("B*55:76")
    assert result.__class__ is Allele, f'Expected parse("B*55:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_77():
    result = parse("B*55:77")
    assert result.__class__ is Allele, f'Expected parse("B*55:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_78():
    result = parse("B*55:78")
    assert result.__class__ is Allele, f'Expected parse("B*55:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_79():
    result = parse("B*55:79")
    assert result.__class__ is Allele, f'Expected parse("B*55:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_80():
    result = parse("B*55:80")
    assert result.__class__ is Allele, f'Expected parse("B*55:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_81():
    result = parse("B*55:81")
    assert result.__class__ is Allele, f'Expected parse("B*55:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_82():
    result = parse("B*55:82")
    assert result.__class__ is Allele, f'Expected parse("B*55:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_83N():
    result = parse("B*55:83N")
    assert result.__class__ is Allele, f'Expected parse("B*55:83N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:83N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_84():
    result = parse("B*55:84")
    assert result.__class__ is Allele, f'Expected parse("B*55:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_85():
    result = parse("B*55:85")
    assert result.__class__ is Allele, f'Expected parse("B*55:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_86():
    result = parse("B*55:86")
    assert result.__class__ is Allele, f'Expected parse("B*55:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_87():
    result = parse("B*55:87")
    assert result.__class__ is Allele, f'Expected parse("B*55:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_88():
    result = parse("B*55:88")
    assert result.__class__ is Allele, f'Expected parse("B*55:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_89N():
    result = parse("B*55:89N")
    assert result.__class__ is Allele, f'Expected parse("B*55:89N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:89N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_90():
    result = parse("B*55:90")
    assert result.__class__ is Allele, f'Expected parse("B*55:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_91():
    result = parse("B*55:91")
    assert result.__class__ is Allele, f'Expected parse("B*55:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_92():
    result = parse("B*55:92")
    assert result.__class__ is Allele, f'Expected parse("B*55:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_93():
    result = parse("B*55:93")
    assert result.__class__ is Allele, f'Expected parse("B*55:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_94():
    result = parse("B*55:94")
    assert result.__class__ is Allele, f'Expected parse("B*55:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_95():
    result = parse("B*55:95")
    assert result.__class__ is Allele, f'Expected parse("B*55:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_96():
    result = parse("B*55:96")
    assert result.__class__ is Allele, f'Expected parse("B*55:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_97N():
    result = parse("B*55:97N")
    assert result.__class__ is Allele, f'Expected parse("B*55:97N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:97N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_98():
    result = parse("B*55:98")
    assert result.__class__ is Allele, f'Expected parse("B*55:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_55_99():
    result = parse("B*55:99")
    assert result.__class__ is Allele, f'Expected parse("B*55:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*55:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_01_01():
    result = parse("B*56:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_01_02():
    result = parse("B*56:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_01_03():
    result = parse("B*56:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_01_04():
    result = parse("B*56:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_01_05S():
    result = parse("B*56:01:01:05S")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:01:01:05S") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:01:01:05S") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_01_06():
    result = parse("B*56:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_01_07():
    result = parse("B*56:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_01_08():
    result = parse("B*56:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_01_09():
    result = parse("B*56:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_01_10():
    result = parse("B*56:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_01_11():
    result = parse("B*56:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_01_12():
    result = parse("B*56:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_02():
    result = parse("B*56:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*56:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_03():
    result = parse("B*56:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*56:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_04():
    result = parse("B*56:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*56:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_05():
    result = parse("B*56:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*56:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_06():
    result = parse("B*56:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*56:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_07():
    result = parse("B*56:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*56:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_08():
    result = parse("B*56:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*56:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_09():
    result = parse("B*56:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*56:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_10():
    result = parse("B*56:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*56:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_11():
    result = parse("B*56:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*56:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_12():
    result = parse("B*56:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*56:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_13():
    result = parse("B*56:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*56:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_14():
    result = parse("B*56:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*56:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_01_15():
    result = parse("B*56:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*56:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_02_01_01():
    result = parse("B*56:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_02_01_02():
    result = parse("B*56:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_02_02():
    result = parse("B*56:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*56:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_02_03():
    result = parse("B*56:02:03")
    assert result.__class__ is Allele, f'Expected parse("B*56:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_03():
    result = parse("B*56:03")
    assert result.__class__ is Allele, f'Expected parse("B*56:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_04_01_01():
    result = parse("B*56:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_04_01_02():
    result = parse("B*56:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_04_01_03():
    result = parse("B*56:04:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:04:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:04:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_04_02():
    result = parse("B*56:04:02")
    assert result.__class__ is Allele, f'Expected parse("B*56:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_04_03():
    result = parse("B*56:04:03")
    assert result.__class__ is Allele, f'Expected parse("B*56:04:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_04_04():
    result = parse("B*56:04:04")
    assert result.__class__ is Allele, f'Expected parse("B*56:04:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:04:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_05_01():
    result = parse("B*56:05:01")
    assert result.__class__ is Allele, f'Expected parse("B*56:05:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_05_02():
    result = parse("B*56:05:02")
    assert result.__class__ is Allele, f'Expected parse("B*56:05:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_06():
    result = parse("B*56:06")
    assert result.__class__ is Allele, f'Expected parse("B*56:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_07():
    result = parse("B*56:07")
    assert result.__class__ is Allele, f'Expected parse("B*56:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_08():
    result = parse("B*56:08")
    assert result.__class__ is Allele, f'Expected parse("B*56:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_09():
    result = parse("B*56:09")
    assert result.__class__ is Allele, f'Expected parse("B*56:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_10():
    result = parse("B*56:10")
    assert result.__class__ is Allele, f'Expected parse("B*56:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_11():
    result = parse("B*56:11")
    assert result.__class__ is Allele, f'Expected parse("B*56:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_12():
    result = parse("B*56:12")
    assert result.__class__ is Allele, f'Expected parse("B*56:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_13():
    result = parse("B*56:13")
    assert result.__class__ is Allele, f'Expected parse("B*56:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_14():
    result = parse("B*56:14")
    assert result.__class__ is Allele, f'Expected parse("B*56:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_15():
    result = parse("B*56:15")
    assert result.__class__ is Allele, f'Expected parse("B*56:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_16():
    result = parse("B*56:16")
    assert result.__class__ is Allele, f'Expected parse("B*56:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_17():
    result = parse("B*56:17")
    assert result.__class__ is Allele, f'Expected parse("B*56:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_18():
    result = parse("B*56:18")
    assert result.__class__ is Allele, f'Expected parse("B*56:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_19N():
    result = parse("B*56:19N")
    assert result.__class__ is Allele, f'Expected parse("B*56:19N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:19N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_20_01():
    result = parse("B*56:20:01")
    assert result.__class__ is Allele, f'Expected parse("B*56:20:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:20:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_20_02():
    result = parse("B*56:20:02")
    assert result.__class__ is Allele, f'Expected parse("B*56:20:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*56:20:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_21():
    result = parse("B*56:21")
    assert result.__class__ is Allele, f'Expected parse("B*56:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_22():
    result = parse("B*56:22")
    assert result.__class__ is Allele, f'Expected parse("B*56:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_23():
    result = parse("B*56:23")
    assert result.__class__ is Allele, f'Expected parse("B*56:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_24():
    result = parse("B*56:24")
    assert result.__class__ is Allele, f'Expected parse("B*56:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_25():
    result = parse("B*56:25")
    assert result.__class__ is Allele, f'Expected parse("B*56:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_26():
    result = parse("B*56:26")
    assert result.__class__ is Allele, f'Expected parse("B*56:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_27():
    result = parse("B*56:27")
    assert result.__class__ is Allele, f'Expected parse("B*56:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_28N():
    result = parse("B*56:28N")
    assert result.__class__ is Allele, f'Expected parse("B*56:28N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:28N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_29():
    result = parse("B*56:29")
    assert result.__class__ is Allele, f'Expected parse("B*56:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_30():
    result = parse("B*56:30")
    assert result.__class__ is Allele, f'Expected parse("B*56:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_31():
    result = parse("B*56:31")
    assert result.__class__ is Allele, f'Expected parse("B*56:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_32():
    result = parse("B*56:32")
    assert result.__class__ is Allele, f'Expected parse("B*56:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_33():
    result = parse("B*56:33")
    assert result.__class__ is Allele, f'Expected parse("B*56:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_34():
    result = parse("B*56:34")
    assert result.__class__ is Allele, f'Expected parse("B*56:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_35():
    result = parse("B*56:35")
    assert result.__class__ is Allele, f'Expected parse("B*56:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_36():
    result = parse("B*56:36")
    assert result.__class__ is Allele, f'Expected parse("B*56:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_37():
    result = parse("B*56:37")
    assert result.__class__ is Allele, f'Expected parse("B*56:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_38N():
    result = parse("B*56:38N")
    assert result.__class__ is Allele, f'Expected parse("B*56:38N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:38N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_39():
    result = parse("B*56:39")
    assert result.__class__ is Allele, f'Expected parse("B*56:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_40():
    result = parse("B*56:40")
    assert result.__class__ is Allele, f'Expected parse("B*56:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_41():
    result = parse("B*56:41")
    assert result.__class__ is Allele, f'Expected parse("B*56:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_42():
    result = parse("B*56:42")
    assert result.__class__ is Allele, f'Expected parse("B*56:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_43():
    result = parse("B*56:43")
    assert result.__class__ is Allele, f'Expected parse("B*56:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_44():
    result = parse("B*56:44")
    assert result.__class__ is Allele, f'Expected parse("B*56:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_45():
    result = parse("B*56:45")
    assert result.__class__ is Allele, f'Expected parse("B*56:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_46():
    result = parse("B*56:46")
    assert result.__class__ is Allele, f'Expected parse("B*56:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_47():
    result = parse("B*56:47")
    assert result.__class__ is Allele, f'Expected parse("B*56:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_48():
    result = parse("B*56:48")
    assert result.__class__ is Allele, f'Expected parse("B*56:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_49():
    result = parse("B*56:49")
    assert result.__class__ is Allele, f'Expected parse("B*56:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_50():
    result = parse("B*56:50")
    assert result.__class__ is Allele, f'Expected parse("B*56:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_51():
    result = parse("B*56:51")
    assert result.__class__ is Allele, f'Expected parse("B*56:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_52():
    result = parse("B*56:52")
    assert result.__class__ is Allele, f'Expected parse("B*56:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_53():
    result = parse("B*56:53")
    assert result.__class__ is Allele, f'Expected parse("B*56:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_54():
    result = parse("B*56:54")
    assert result.__class__ is Allele, f'Expected parse("B*56:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_55_01_02():
    result = parse("B*56:55:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*56:55:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*56:55:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_56():
    result = parse("B*56:56")
    assert result.__class__ is Allele, f'Expected parse("B*56:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_57():
    result = parse("B*56:57")
    assert result.__class__ is Allele, f'Expected parse("B*56:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_58():
    result = parse("B*56:58")
    assert result.__class__ is Allele, f'Expected parse("B*56:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_59():
    result = parse("B*56:59")
    assert result.__class__ is Allele, f'Expected parse("B*56:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_60():
    result = parse("B*56:60")
    assert result.__class__ is Allele, f'Expected parse("B*56:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_61():
    result = parse("B*56:61")
    assert result.__class__ is Allele, f'Expected parse("B*56:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_62():
    result = parse("B*56:62")
    assert result.__class__ is Allele, f'Expected parse("B*56:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_63():
    result = parse("B*56:63")
    assert result.__class__ is Allele, f'Expected parse("B*56:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_64():
    result = parse("B*56:64")
    assert result.__class__ is Allele, f'Expected parse("B*56:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_65():
    result = parse("B*56:65")
    assert result.__class__ is Allele, f'Expected parse("B*56:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_66():
    result = parse("B*56:66")
    assert result.__class__ is Allele, f'Expected parse("B*56:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_67():
    result = parse("B*56:67")
    assert result.__class__ is Allele, f'Expected parse("B*56:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_68():
    result = parse("B*56:68")
    assert result.__class__ is Allele, f'Expected parse("B*56:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_69():
    result = parse("B*56:69")
    assert result.__class__ is Allele, f'Expected parse("B*56:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_70():
    result = parse("B*56:70")
    assert result.__class__ is Allele, f'Expected parse("B*56:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_71():
    result = parse("B*56:71")
    assert result.__class__ is Allele, f'Expected parse("B*56:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_72():
    result = parse("B*56:72")
    assert result.__class__ is Allele, f'Expected parse("B*56:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_73():
    result = parse("B*56:73")
    assert result.__class__ is Allele, f'Expected parse("B*56:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_56_74():
    result = parse("B*56:74")
    assert result.__class__ is Allele, f'Expected parse("B*56:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*56:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_01_01():
    result = parse("B*57:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_01_02():
    result = parse("B*57:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_01_03():
    result = parse("B*57:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_01_04():
    result = parse("B*57:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_01_05():
    result = parse("B*57:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_01_06():
    result = parse("B*57:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_01_07():
    result = parse("B*57:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_01_08():
    result = parse("B*57:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_01_09():
    result = parse("B*57:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_01_10():
    result = parse("B*57:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_01_11():
    result = parse("B*57:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_01_12():
    result = parse("B*57:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_01_13():
    result = parse("B*57:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_01_14():
    result = parse("B*57:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_01_15():
    result = parse("B*57:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_01_16():
    result = parse("B*57:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_02():
    result = parse("B*57:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_03():
    result = parse("B*57:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_04():
    result = parse("B*57:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_05():
    result = parse("B*57:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_06():
    result = parse("B*57:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_07():
    result = parse("B*57:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_08():
    result = parse("B*57:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_09():
    result = parse("B*57:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_10():
    result = parse("B*57:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_11():
    result = parse("B*57:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_12():
    result = parse("B*57:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_13():
    result = parse("B*57:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_14():
    result = parse("B*57:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_15():
    result = parse("B*57:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_16():
    result = parse("B*57:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_17():
    result = parse("B*57:01:17")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_18():
    result = parse("B*57:01:18")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_19():
    result = parse("B*57:01:19")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_20():
    result = parse("B*57:01:20")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_21():
    result = parse("B*57:01:21")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_22():
    result = parse("B*57:01:22")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_23():
    result = parse("B*57:01:23")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_24():
    result = parse("B*57:01:24")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_25():
    result = parse("B*57:01:25")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_26():
    result = parse("B*57:01:26")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_27():
    result = parse("B*57:01:27")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_28():
    result = parse("B*57:01:28")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_29():
    result = parse("B*57:01:29")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_30():
    result = parse("B*57:01:30")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_31():
    result = parse("B*57:01:31")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_32():
    result = parse("B*57:01:32")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_33():
    result = parse("B*57:01:33")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_34():
    result = parse("B*57:01:34")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_35():
    result = parse("B*57:01:35")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_36():
    result = parse("B*57:01:36")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_37():
    result = parse("B*57:01:37")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_38():
    result = parse("B*57:01:38")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_39():
    result = parse("B*57:01:39")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_40():
    result = parse("B*57:01:40")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_41():
    result = parse("B*57:01:41")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_42():
    result = parse("B*57:01:42")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_01_43():
    result = parse("B*57:01:43")
    assert result.__class__ is Allele, f'Expected parse("B*57:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_02_01_01():
    result = parse("B*57:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_02_01_02():
    result = parse("B*57:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_02_02():
    result = parse("B*57:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*57:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_03_01_01():
    result = parse("B*57:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_03_01_02():
    result = parse("B*57:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_03_01_03():
    result = parse("B*57:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_03_01_04():
    result = parse("B*57:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_03_01_05():
    result = parse("B*57:03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*57:03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*57:03:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_03_02():
    result = parse("B*57:03:02")
    assert result.__class__ is Allele, f'Expected parse("B*57:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_03_03():
    result = parse("B*57:03:03")
    assert result.__class__ is Allele, f'Expected parse("B*57:03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_03_04():
    result = parse("B*57:03:04")
    assert result.__class__ is Allele, f'Expected parse("B*57:03:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_03_05():
    result = parse("B*57:03:05")
    assert result.__class__ is Allele, f'Expected parse("B*57:03:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_04_01():
    result = parse("B*57:04:01")
    assert result.__class__ is Allele, f'Expected parse("B*57:04:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_04_02():
    result = parse("B*57:04:02")
    assert result.__class__ is Allele, f'Expected parse("B*57:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_04_03():
    result = parse("B*57:04:03")
    assert result.__class__ is Allele, f'Expected parse("B*57:04:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_05():
    result = parse("B*57:05")
    assert result.__class__ is Allele, f'Expected parse("B*57:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_06():
    result = parse("B*57:06")
    assert result.__class__ is Allele, f'Expected parse("B*57:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_07():
    result = parse("B*57:07")
    assert result.__class__ is Allele, f'Expected parse("B*57:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_08():
    result = parse("B*57:08")
    assert result.__class__ is Allele, f'Expected parse("B*57:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_09():
    result = parse("B*57:09")
    assert result.__class__ is Allele, f'Expected parse("B*57:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_10():
    result = parse("B*57:10")
    assert result.__class__ is Allele, f'Expected parse("B*57:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_100():
    result = parse("B*57:100")
    assert result.__class__ is Allele, f'Expected parse("B*57:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_101():
    result = parse("B*57:101")
    assert result.__class__ is Allele, f'Expected parse("B*57:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_102():
    result = parse("B*57:102")
    assert result.__class__ is Allele, f'Expected parse("B*57:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_103():
    result = parse("B*57:103")
    assert result.__class__ is Allele, f'Expected parse("B*57:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_104():
    result = parse("B*57:104")
    assert result.__class__ is Allele, f'Expected parse("B*57:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_105():
    result = parse("B*57:105")
    assert result.__class__ is Allele, f'Expected parse("B*57:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_106():
    result = parse("B*57:106")
    assert result.__class__ is Allele, f'Expected parse("B*57:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_107():
    result = parse("B*57:107")
    assert result.__class__ is Allele, f'Expected parse("B*57:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_108():
    result = parse("B*57:108")
    assert result.__class__ is Allele, f'Expected parse("B*57:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_109():
    result = parse("B*57:109")
    assert result.__class__ is Allele, f'Expected parse("B*57:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_11():
    result = parse("B*57:11")
    assert result.__class__ is Allele, f'Expected parse("B*57:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_110():
    result = parse("B*57:110")
    assert result.__class__ is Allele, f'Expected parse("B*57:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_111():
    result = parse("B*57:111")
    assert result.__class__ is Allele, f'Expected parse("B*57:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_112():
    result = parse("B*57:112")
    assert result.__class__ is Allele, f'Expected parse("B*57:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_113():
    result = parse("B*57:113")
    assert result.__class__ is Allele, f'Expected parse("B*57:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_114():
    result = parse("B*57:114")
    assert result.__class__ is Allele, f'Expected parse("B*57:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_115():
    result = parse("B*57:115")
    assert result.__class__ is Allele, f'Expected parse("B*57:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_116():
    result = parse("B*57:116")
    assert result.__class__ is Allele, f'Expected parse("B*57:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_117():
    result = parse("B*57:117")
    assert result.__class__ is Allele, f'Expected parse("B*57:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_118():
    result = parse("B*57:118")
    assert result.__class__ is Allele, f'Expected parse("B*57:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_119():
    result = parse("B*57:119")
    assert result.__class__ is Allele, f'Expected parse("B*57:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_12():
    result = parse("B*57:12")
    assert result.__class__ is Allele, f'Expected parse("B*57:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_120():
    result = parse("B*57:120")
    assert result.__class__ is Allele, f'Expected parse("B*57:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_121():
    result = parse("B*57:121")
    assert result.__class__ is Allele, f'Expected parse("B*57:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_122N():
    result = parse("B*57:122N")
    assert result.__class__ is Allele, f'Expected parse("B*57:122N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:122N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_123():
    result = parse("B*57:123")
    assert result.__class__ is Allele, f'Expected parse("B*57:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_124():
    result = parse("B*57:124")
    assert result.__class__ is Allele, f'Expected parse("B*57:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_125():
    result = parse("B*57:125")
    assert result.__class__ is Allele, f'Expected parse("B*57:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_126():
    result = parse("B*57:126")
    assert result.__class__ is Allele, f'Expected parse("B*57:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_127():
    result = parse("B*57:127")
    assert result.__class__ is Allele, f'Expected parse("B*57:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_128():
    result = parse("B*57:128")
    assert result.__class__ is Allele, f'Expected parse("B*57:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_129():
    result = parse("B*57:129")
    assert result.__class__ is Allele, f'Expected parse("B*57:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_13():
    result = parse("B*57:13")
    assert result.__class__ is Allele, f'Expected parse("B*57:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_130N():
    result = parse("B*57:130N")
    assert result.__class__ is Allele, f'Expected parse("B*57:130N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:130N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_131():
    result = parse("B*57:131")
    assert result.__class__ is Allele, f'Expected parse("B*57:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_132():
    result = parse("B*57:132")
    assert result.__class__ is Allele, f'Expected parse("B*57:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_133():
    result = parse("B*57:133")
    assert result.__class__ is Allele, f'Expected parse("B*57:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_134():
    result = parse("B*57:134")
    assert result.__class__ is Allele, f'Expected parse("B*57:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_14_01():
    result = parse("B*57:14:01")
    assert result.__class__ is Allele, f'Expected parse("B*57:14:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:14:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_14_02():
    result = parse("B*57:14:02")
    assert result.__class__ is Allele, f'Expected parse("B*57:14:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:14:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_15():
    result = parse("B*57:15")
    assert result.__class__ is Allele, f'Expected parse("B*57:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_16():
    result = parse("B*57:16")
    assert result.__class__ is Allele, f'Expected parse("B*57:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_17():
    result = parse("B*57:17")
    assert result.__class__ is Allele, f'Expected parse("B*57:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_18():
    result = parse("B*57:18")
    assert result.__class__ is Allele, f'Expected parse("B*57:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_19():
    result = parse("B*57:19")
    assert result.__class__ is Allele, f'Expected parse("B*57:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_20():
    result = parse("B*57:20")
    assert result.__class__ is Allele, f'Expected parse("B*57:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_21():
    result = parse("B*57:21")
    assert result.__class__ is Allele, f'Expected parse("B*57:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_22():
    result = parse("B*57:22")
    assert result.__class__ is Allele, f'Expected parse("B*57:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_23():
    result = parse("B*57:23")
    assert result.__class__ is Allele, f'Expected parse("B*57:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_24():
    result = parse("B*57:24")
    assert result.__class__ is Allele, f'Expected parse("B*57:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_25():
    result = parse("B*57:25")
    assert result.__class__ is Allele, f'Expected parse("B*57:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_26():
    result = parse("B*57:26")
    assert result.__class__ is Allele, f'Expected parse("B*57:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_27():
    result = parse("B*57:27")
    assert result.__class__ is Allele, f'Expected parse("B*57:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_28N():
    result = parse("B*57:28N")
    assert result.__class__ is Allele, f'Expected parse("B*57:28N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:28N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_29():
    result = parse("B*57:29")
    assert result.__class__ is Allele, f'Expected parse("B*57:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_30():
    result = parse("B*57:30")
    assert result.__class__ is Allele, f'Expected parse("B*57:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_31_01():
    result = parse("B*57:31:01")
    assert result.__class__ is Allele, f'Expected parse("B*57:31:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:31:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_31_02():
    result = parse("B*57:31:02")
    assert result.__class__ is Allele, f'Expected parse("B*57:31:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:31:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_32():
    result = parse("B*57:32")
    assert result.__class__ is Allele, f'Expected parse("B*57:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_33():
    result = parse("B*57:33")
    assert result.__class__ is Allele, f'Expected parse("B*57:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_34():
    result = parse("B*57:34")
    assert result.__class__ is Allele, f'Expected parse("B*57:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_35():
    result = parse("B*57:35")
    assert result.__class__ is Allele, f'Expected parse("B*57:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_36():
    result = parse("B*57:36")
    assert result.__class__ is Allele, f'Expected parse("B*57:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_37():
    result = parse("B*57:37")
    assert result.__class__ is Allele, f'Expected parse("B*57:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_38():
    result = parse("B*57:38")
    assert result.__class__ is Allele, f'Expected parse("B*57:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_39():
    result = parse("B*57:39")
    assert result.__class__ is Allele, f'Expected parse("B*57:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_40():
    result = parse("B*57:40")
    assert result.__class__ is Allele, f'Expected parse("B*57:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_41():
    result = parse("B*57:41")
    assert result.__class__ is Allele, f'Expected parse("B*57:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_42():
    result = parse("B*57:42")
    assert result.__class__ is Allele, f'Expected parse("B*57:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_43():
    result = parse("B*57:43")
    assert result.__class__ is Allele, f'Expected parse("B*57:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_44():
    result = parse("B*57:44")
    assert result.__class__ is Allele, f'Expected parse("B*57:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_45():
    result = parse("B*57:45")
    assert result.__class__ is Allele, f'Expected parse("B*57:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_46():
    result = parse("B*57:46")
    assert result.__class__ is Allele, f'Expected parse("B*57:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_47():
    result = parse("B*57:47")
    assert result.__class__ is Allele, f'Expected parse("B*57:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_48():
    result = parse("B*57:48")
    assert result.__class__ is Allele, f'Expected parse("B*57:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_49():
    result = parse("B*57:49")
    assert result.__class__ is Allele, f'Expected parse("B*57:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_50():
    result = parse("B*57:50")
    assert result.__class__ is Allele, f'Expected parse("B*57:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_51():
    result = parse("B*57:51")
    assert result.__class__ is Allele, f'Expected parse("B*57:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_52():
    result = parse("B*57:52")
    assert result.__class__ is Allele, f'Expected parse("B*57:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_53():
    result = parse("B*57:53")
    assert result.__class__ is Allele, f'Expected parse("B*57:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_54():
    result = parse("B*57:54")
    assert result.__class__ is Allele, f'Expected parse("B*57:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_55():
    result = parse("B*57:55")
    assert result.__class__ is Allele, f'Expected parse("B*57:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_56():
    result = parse("B*57:56")
    assert result.__class__ is Allele, f'Expected parse("B*57:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_57():
    result = parse("B*57:57")
    assert result.__class__ is Allele, f'Expected parse("B*57:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_58():
    result = parse("B*57:58")
    assert result.__class__ is Allele, f'Expected parse("B*57:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_59():
    result = parse("B*57:59")
    assert result.__class__ is Allele, f'Expected parse("B*57:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_60():
    result = parse("B*57:60")
    assert result.__class__ is Allele, f'Expected parse("B*57:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_61():
    result = parse("B*57:61")
    assert result.__class__ is Allele, f'Expected parse("B*57:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_62():
    result = parse("B*57:62")
    assert result.__class__ is Allele, f'Expected parse("B*57:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_63():
    result = parse("B*57:63")
    assert result.__class__ is Allele, f'Expected parse("B*57:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_64():
    result = parse("B*57:64")
    assert result.__class__ is Allele, f'Expected parse("B*57:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_65():
    result = parse("B*57:65")
    assert result.__class__ is Allele, f'Expected parse("B*57:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_66():
    result = parse("B*57:66")
    assert result.__class__ is Allele, f'Expected parse("B*57:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_67_01():
    result = parse("B*57:67:01")
    assert result.__class__ is Allele, f'Expected parse("B*57:67:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:67:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_67_02():
    result = parse("B*57:67:02")
    assert result.__class__ is Allele, f'Expected parse("B*57:67:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*57:67:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_68():
    result = parse("B*57:68")
    assert result.__class__ is Allele, f'Expected parse("B*57:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_69():
    result = parse("B*57:69")
    assert result.__class__ is Allele, f'Expected parse("B*57:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_70():
    result = parse("B*57:70")
    assert result.__class__ is Allele, f'Expected parse("B*57:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_71():
    result = parse("B*57:71")
    assert result.__class__ is Allele, f'Expected parse("B*57:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_72():
    result = parse("B*57:72")
    assert result.__class__ is Allele, f'Expected parse("B*57:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_73():
    result = parse("B*57:73")
    assert result.__class__ is Allele, f'Expected parse("B*57:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_74():
    result = parse("B*57:74")
    assert result.__class__ is Allele, f'Expected parse("B*57:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_75():
    result = parse("B*57:75")
    assert result.__class__ is Allele, f'Expected parse("B*57:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_76():
    result = parse("B*57:76")
    assert result.__class__ is Allele, f'Expected parse("B*57:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_77():
    result = parse("B*57:77")
    assert result.__class__ is Allele, f'Expected parse("B*57:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_78():
    result = parse("B*57:78")
    assert result.__class__ is Allele, f'Expected parse("B*57:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_79N():
    result = parse("B*57:79N")
    assert result.__class__ is Allele, f'Expected parse("B*57:79N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:79N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_80():
    result = parse("B*57:80")
    assert result.__class__ is Allele, f'Expected parse("B*57:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_81():
    result = parse("B*57:81")
    assert result.__class__ is Allele, f'Expected parse("B*57:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_82():
    result = parse("B*57:82")
    assert result.__class__ is Allele, f'Expected parse("B*57:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_83():
    result = parse("B*57:83")
    assert result.__class__ is Allele, f'Expected parse("B*57:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_84():
    result = parse("B*57:84")
    assert result.__class__ is Allele, f'Expected parse("B*57:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_85():
    result = parse("B*57:85")
    assert result.__class__ is Allele, f'Expected parse("B*57:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_86():
    result = parse("B*57:86")
    assert result.__class__ is Allele, f'Expected parse("B*57:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_87():
    result = parse("B*57:87")
    assert result.__class__ is Allele, f'Expected parse("B*57:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_88():
    result = parse("B*57:88")
    assert result.__class__ is Allele, f'Expected parse("B*57:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_89():
    result = parse("B*57:89")
    assert result.__class__ is Allele, f'Expected parse("B*57:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_90():
    result = parse("B*57:90")
    assert result.__class__ is Allele, f'Expected parse("B*57:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_91():
    result = parse("B*57:91")
    assert result.__class__ is Allele, f'Expected parse("B*57:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_92():
    result = parse("B*57:92")
    assert result.__class__ is Allele, f'Expected parse("B*57:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_93():
    result = parse("B*57:93")
    assert result.__class__ is Allele, f'Expected parse("B*57:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_94():
    result = parse("B*57:94")
    assert result.__class__ is Allele, f'Expected parse("B*57:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_95():
    result = parse("B*57:95")
    assert result.__class__ is Allele, f'Expected parse("B*57:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_96():
    result = parse("B*57:96")
    assert result.__class__ is Allele, f'Expected parse("B*57:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_97():
    result = parse("B*57:97")
    assert result.__class__ is Allele, f'Expected parse("B*57:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_98Q():
    result = parse("B*57:98Q")
    assert result.__class__ is Allele, f'Expected parse("B*57:98Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:98Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_57_99():
    result = parse("B*57:99")
    assert result.__class__ is Allele, f'Expected parse("B*57:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*57:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_01_01():
    result = parse("B*58:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*58:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*58:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_01_02():
    result = parse("B*58:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*58:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*58:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_01_03():
    result = parse("B*58:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*58:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*58:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_01_04():
    result = parse("B*58:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("B*58:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*58:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_01_05():
    result = parse("B*58:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("B*58:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*58:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_01_06():
    result = parse("B*58:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("B*58:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*58:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_01_07():
    result = parse("B*58:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("B*58:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*58:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_01_08():
    result = parse("B*58:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("B*58:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*58:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_01_09():
    result = parse("B*58:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("B*58:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*58:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_02():
    result = parse("B*58:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_03():
    result = parse("B*58:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_04():
    result = parse("B*58:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_05():
    result = parse("B*58:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_06():
    result = parse("B*58:01:06")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_07():
    result = parse("B*58:01:07")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_08():
    result = parse("B*58:01:08")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_09():
    result = parse("B*58:01:09")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_10():
    result = parse("B*58:01:10")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_11():
    result = parse("B*58:01:11")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_12():
    result = parse("B*58:01:12")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_13():
    result = parse("B*58:01:13")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_14():
    result = parse("B*58:01:14")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_15():
    result = parse("B*58:01:15")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_16():
    result = parse("B*58:01:16")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_17():
    result = parse("B*58:01:17")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_18():
    result = parse("B*58:01:18")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_19():
    result = parse("B*58:01:19")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_20():
    result = parse("B*58:01:20")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_21():
    result = parse("B*58:01:21")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_22():
    result = parse("B*58:01:22")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_23():
    result = parse("B*58:01:23")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_24():
    result = parse("B*58:01:24")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_25():
    result = parse("B*58:01:25")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_26():
    result = parse("B*58:01:26")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_27():
    result = parse("B*58:01:27")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_28():
    result = parse("B*58:01:28")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_29():
    result = parse("B*58:01:29")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_30():
    result = parse("B*58:01:30")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_31():
    result = parse("B*58:01:31")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_32():
    result = parse("B*58:01:32")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_33():
    result = parse("B*58:01:33")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_34():
    result = parse("B*58:01:34")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_01_35():
    result = parse("B*58:01:35")
    assert result.__class__ is Allele, f'Expected parse("B*58:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_02_01_01():
    result = parse("B*58:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*58:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*58:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_02_01_02():
    result = parse("B*58:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*58:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*58:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_02_01_03():
    result = parse("B*58:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*58:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*58:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_02_02():
    result = parse("B*58:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*58:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_04():
    result = parse("B*58:04")
    assert result.__class__ is Allele, f'Expected parse("B*58:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_05():
    result = parse("B*58:05")
    assert result.__class__ is Allele, f'Expected parse("B*58:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_06():
    result = parse("B*58:06")
    assert result.__class__ is Allele, f'Expected parse("B*58:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_07():
    result = parse("B*58:07")
    assert result.__class__ is Allele, f'Expected parse("B*58:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_08_01():
    result = parse("B*58:08:01")
    assert result.__class__ is Allele, f'Expected parse("B*58:08:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:08:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_08_02():
    result = parse("B*58:08:02")
    assert result.__class__ is Allele, f'Expected parse("B*58:08:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:08:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_09():
    result = parse("B*58:09")
    assert result.__class__ is Allele, f'Expected parse("B*58:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_100():
    result = parse("B*58:100")
    assert result.__class__ is Allele, f'Expected parse("B*58:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_101():
    result = parse("B*58:101")
    assert result.__class__ is Allele, f'Expected parse("B*58:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_102():
    result = parse("B*58:102")
    assert result.__class__ is Allele, f'Expected parse("B*58:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_103():
    result = parse("B*58:103")
    assert result.__class__ is Allele, f'Expected parse("B*58:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_104():
    result = parse("B*58:104")
    assert result.__class__ is Allele, f'Expected parse("B*58:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_105():
    result = parse("B*58:105")
    assert result.__class__ is Allele, f'Expected parse("B*58:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_106():
    result = parse("B*58:106")
    assert result.__class__ is Allele, f'Expected parse("B*58:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_107():
    result = parse("B*58:107")
    assert result.__class__ is Allele, f'Expected parse("B*58:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_108():
    result = parse("B*58:108")
    assert result.__class__ is Allele, f'Expected parse("B*58:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_109():
    result = parse("B*58:109")
    assert result.__class__ is Allele, f'Expected parse("B*58:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_10N():
    result = parse("B*58:10N")
    assert result.__class__ is Allele, f'Expected parse("B*58:10N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:10N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_11():
    result = parse("B*58:11")
    assert result.__class__ is Allele, f'Expected parse("B*58:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_110():
    result = parse("B*58:110")
    assert result.__class__ is Allele, f'Expected parse("B*58:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_111():
    result = parse("B*58:111")
    assert result.__class__ is Allele, f'Expected parse("B*58:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_112():
    result = parse("B*58:112")
    assert result.__class__ is Allele, f'Expected parse("B*58:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_113():
    result = parse("B*58:113")
    assert result.__class__ is Allele, f'Expected parse("B*58:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_114():
    result = parse("B*58:114")
    assert result.__class__ is Allele, f'Expected parse("B*58:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_115():
    result = parse("B*58:115")
    assert result.__class__ is Allele, f'Expected parse("B*58:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_116():
    result = parse("B*58:116")
    assert result.__class__ is Allele, f'Expected parse("B*58:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_117():
    result = parse("B*58:117")
    assert result.__class__ is Allele, f'Expected parse("B*58:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_118():
    result = parse("B*58:118")
    assert result.__class__ is Allele, f'Expected parse("B*58:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_119():
    result = parse("B*58:119")
    assert result.__class__ is Allele, f'Expected parse("B*58:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_12():
    result = parse("B*58:12")
    assert result.__class__ is Allele, f'Expected parse("B*58:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_120():
    result = parse("B*58:120")
    assert result.__class__ is Allele, f'Expected parse("B*58:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_121():
    result = parse("B*58:121")
    assert result.__class__ is Allele, f'Expected parse("B*58:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_122():
    result = parse("B*58:122")
    assert result.__class__ is Allele, f'Expected parse("B*58:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_123():
    result = parse("B*58:123")
    assert result.__class__ is Allele, f'Expected parse("B*58:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_124():
    result = parse("B*58:124")
    assert result.__class__ is Allele, f'Expected parse("B*58:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_125():
    result = parse("B*58:125")
    assert result.__class__ is Allele, f'Expected parse("B*58:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_126():
    result = parse("B*58:126")
    assert result.__class__ is Allele, f'Expected parse("B*58:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_13():
    result = parse("B*58:13")
    assert result.__class__ is Allele, f'Expected parse("B*58:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_14():
    result = parse("B*58:14")
    assert result.__class__ is Allele, f'Expected parse("B*58:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_15():
    result = parse("B*58:15")
    assert result.__class__ is Allele, f'Expected parse("B*58:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_16_01():
    result = parse("B*58:16:01")
    assert result.__class__ is Allele, f'Expected parse("B*58:16:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:16:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_16_02():
    result = parse("B*58:16:02")
    assert result.__class__ is Allele, f'Expected parse("B*58:16:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:16:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_17N():
    result = parse("B*58:17N")
    assert result.__class__ is Allele, f'Expected parse("B*58:17N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:17N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_18():
    result = parse("B*58:18")
    assert result.__class__ is Allele, f'Expected parse("B*58:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_19():
    result = parse("B*58:19")
    assert result.__class__ is Allele, f'Expected parse("B*58:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_20():
    result = parse("B*58:20")
    assert result.__class__ is Allele, f'Expected parse("B*58:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_21():
    result = parse("B*58:21")
    assert result.__class__ is Allele, f'Expected parse("B*58:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_22():
    result = parse("B*58:22")
    assert result.__class__ is Allele, f'Expected parse("B*58:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_23():
    result = parse("B*58:23")
    assert result.__class__ is Allele, f'Expected parse("B*58:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_24():
    result = parse("B*58:24")
    assert result.__class__ is Allele, f'Expected parse("B*58:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_25():
    result = parse("B*58:25")
    assert result.__class__ is Allele, f'Expected parse("B*58:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_26():
    result = parse("B*58:26")
    assert result.__class__ is Allele, f'Expected parse("B*58:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_27():
    result = parse("B*58:27")
    assert result.__class__ is Allele, f'Expected parse("B*58:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_28_01():
    result = parse("B*58:28:01")
    assert result.__class__ is Allele, f'Expected parse("B*58:28:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:28:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_28_02():
    result = parse("B*58:28:02")
    assert result.__class__ is Allele, f'Expected parse("B*58:28:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:28:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_29():
    result = parse("B*58:29")
    assert result.__class__ is Allele, f'Expected parse("B*58:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_31N():
    result = parse("B*58:31N")
    assert result.__class__ is Allele, f'Expected parse("B*58:31N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:31N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_32():
    result = parse("B*58:32")
    assert result.__class__ is Allele, f'Expected parse("B*58:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_33():
    result = parse("B*58:33")
    assert result.__class__ is Allele, f'Expected parse("B*58:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_34():
    result = parse("B*58:34")
    assert result.__class__ is Allele, f'Expected parse("B*58:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_35():
    result = parse("B*58:35")
    assert result.__class__ is Allele, f'Expected parse("B*58:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_36():
    result = parse("B*58:36")
    assert result.__class__ is Allele, f'Expected parse("B*58:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_37():
    result = parse("B*58:37")
    assert result.__class__ is Allele, f'Expected parse("B*58:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_38():
    result = parse("B*58:38")
    assert result.__class__ is Allele, f'Expected parse("B*58:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_39N():
    result = parse("B*58:39N")
    assert result.__class__ is Allele, f'Expected parse("B*58:39N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:39N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_40():
    result = parse("B*58:40")
    assert result.__class__ is Allele, f'Expected parse("B*58:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_41():
    result = parse("B*58:41")
    assert result.__class__ is Allele, f'Expected parse("B*58:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_42():
    result = parse("B*58:42")
    assert result.__class__ is Allele, f'Expected parse("B*58:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_43():
    result = parse("B*58:43")
    assert result.__class__ is Allele, f'Expected parse("B*58:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_44():
    result = parse("B*58:44")
    assert result.__class__ is Allele, f'Expected parse("B*58:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_45_01():
    result = parse("B*58:45:01")
    assert result.__class__ is Allele, f'Expected parse("B*58:45:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:45:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_45_02():
    result = parse("B*58:45:02")
    assert result.__class__ is Allele, f'Expected parse("B*58:45:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:45:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_46():
    result = parse("B*58:46")
    assert result.__class__ is Allele, f'Expected parse("B*58:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_47():
    result = parse("B*58:47")
    assert result.__class__ is Allele, f'Expected parse("B*58:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_48():
    result = parse("B*58:48")
    assert result.__class__ is Allele, f'Expected parse("B*58:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_49():
    result = parse("B*58:49")
    assert result.__class__ is Allele, f'Expected parse("B*58:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_50():
    result = parse("B*58:50")
    assert result.__class__ is Allele, f'Expected parse("B*58:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_51():
    result = parse("B*58:51")
    assert result.__class__ is Allele, f'Expected parse("B*58:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_52():
    result = parse("B*58:52")
    assert result.__class__ is Allele, f'Expected parse("B*58:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_53():
    result = parse("B*58:53")
    assert result.__class__ is Allele, f'Expected parse("B*58:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_54():
    result = parse("B*58:54")
    assert result.__class__ is Allele, f'Expected parse("B*58:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_55():
    result = parse("B*58:55")
    assert result.__class__ is Allele, f'Expected parse("B*58:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_56():
    result = parse("B*58:56")
    assert result.__class__ is Allele, f'Expected parse("B*58:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_57():
    result = parse("B*58:57")
    assert result.__class__ is Allele, f'Expected parse("B*58:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_58():
    result = parse("B*58:58")
    assert result.__class__ is Allele, f'Expected parse("B*58:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_59_01():
    result = parse("B*58:59:01")
    assert result.__class__ is Allele, f'Expected parse("B*58:59:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:59:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_59_02():
    result = parse("B*58:59:02")
    assert result.__class__ is Allele, f'Expected parse("B*58:59:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*58:59:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_60():
    result = parse("B*58:60")
    assert result.__class__ is Allele, f'Expected parse("B*58:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_61():
    result = parse("B*58:61")
    assert result.__class__ is Allele, f'Expected parse("B*58:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_62():
    result = parse("B*58:62")
    assert result.__class__ is Allele, f'Expected parse("B*58:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_63():
    result = parse("B*58:63")
    assert result.__class__ is Allele, f'Expected parse("B*58:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_64():
    result = parse("B*58:64")
    assert result.__class__ is Allele, f'Expected parse("B*58:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_65():
    result = parse("B*58:65")
    assert result.__class__ is Allele, f'Expected parse("B*58:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_66():
    result = parse("B*58:66")
    assert result.__class__ is Allele, f'Expected parse("B*58:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_67():
    result = parse("B*58:67")
    assert result.__class__ is Allele, f'Expected parse("B*58:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_68():
    result = parse("B*58:68")
    assert result.__class__ is Allele, f'Expected parse("B*58:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_69():
    result = parse("B*58:69")
    assert result.__class__ is Allele, f'Expected parse("B*58:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_70():
    result = parse("B*58:70")
    assert result.__class__ is Allele, f'Expected parse("B*58:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_71():
    result = parse("B*58:71")
    assert result.__class__ is Allele, f'Expected parse("B*58:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_72N():
    result = parse("B*58:72N")
    assert result.__class__ is Allele, f'Expected parse("B*58:72N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:72N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_73():
    result = parse("B*58:73")
    assert result.__class__ is Allele, f'Expected parse("B*58:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_74():
    result = parse("B*58:74")
    assert result.__class__ is Allele, f'Expected parse("B*58:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_75():
    result = parse("B*58:75")
    assert result.__class__ is Allele, f'Expected parse("B*58:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_76():
    result = parse("B*58:76")
    assert result.__class__ is Allele, f'Expected parse("B*58:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_77():
    result = parse("B*58:77")
    assert result.__class__ is Allele, f'Expected parse("B*58:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_78():
    result = parse("B*58:78")
    assert result.__class__ is Allele, f'Expected parse("B*58:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_79():
    result = parse("B*58:79")
    assert result.__class__ is Allele, f'Expected parse("B*58:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_80():
    result = parse("B*58:80")
    assert result.__class__ is Allele, f'Expected parse("B*58:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_81():
    result = parse("B*58:81")
    assert result.__class__ is Allele, f'Expected parse("B*58:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_82():
    result = parse("B*58:82")
    assert result.__class__ is Allele, f'Expected parse("B*58:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_83():
    result = parse("B*58:83")
    assert result.__class__ is Allele, f'Expected parse("B*58:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_84():
    result = parse("B*58:84")
    assert result.__class__ is Allele, f'Expected parse("B*58:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_85():
    result = parse("B*58:85")
    assert result.__class__ is Allele, f'Expected parse("B*58:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_86():
    result = parse("B*58:86")
    assert result.__class__ is Allele, f'Expected parse("B*58:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_87():
    result = parse("B*58:87")
    assert result.__class__ is Allele, f'Expected parse("B*58:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_88():
    result = parse("B*58:88")
    assert result.__class__ is Allele, f'Expected parse("B*58:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_89():
    result = parse("B*58:89")
    assert result.__class__ is Allele, f'Expected parse("B*58:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_90():
    result = parse("B*58:90")
    assert result.__class__ is Allele, f'Expected parse("B*58:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_91():
    result = parse("B*58:91")
    assert result.__class__ is Allele, f'Expected parse("B*58:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_92():
    result = parse("B*58:92")
    assert result.__class__ is Allele, f'Expected parse("B*58:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_93N():
    result = parse("B*58:93N")
    assert result.__class__ is Allele, f'Expected parse("B*58:93N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:93N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_94N():
    result = parse("B*58:94N")
    assert result.__class__ is Allele, f'Expected parse("B*58:94N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:94N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_95():
    result = parse("B*58:95")
    assert result.__class__ is Allele, f'Expected parse("B*58:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_96():
    result = parse("B*58:96")
    assert result.__class__ is Allele, f'Expected parse("B*58:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_97():
    result = parse("B*58:97")
    assert result.__class__ is Allele, f'Expected parse("B*58:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_98():
    result = parse("B*58:98")
    assert result.__class__ is Allele, f'Expected parse("B*58:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_58_99():
    result = parse("B*58:99")
    assert result.__class__ is Allele, f'Expected parse("B*58:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*58:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_59_01_01_01():
    result = parse("B*59:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*59:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*59:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_59_01_01_02():
    result = parse("B*59:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*59:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*59:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_59_02():
    result = parse("B*59:02")
    assert result.__class__ is Allele, f'Expected parse("B*59:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*59:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_59_03():
    result = parse("B*59:03")
    assert result.__class__ is Allele, f'Expected parse("B*59:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*59:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_59_04():
    result = parse("B*59:04")
    assert result.__class__ is Allele, f'Expected parse("B*59:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*59:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_59_05():
    result = parse("B*59:05")
    assert result.__class__ is Allele, f'Expected parse("B*59:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*59:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_59_06():
    result = parse("B*59:06")
    assert result.__class__ is Allele, f'Expected parse("B*59:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*59:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_59_07():
    result = parse("B*59:07")
    assert result.__class__ is Allele, f'Expected parse("B*59:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*59:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_59_08():
    result = parse("B*59:08")
    assert result.__class__ is Allele, f'Expected parse("B*59:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*59:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_59_09():
    result = parse("B*59:09")
    assert result.__class__ is Allele, f'Expected parse("B*59:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*59:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_59_10N():
    result = parse("B*59:10N")
    assert result.__class__ is Allele, f'Expected parse("B*59:10N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*59:10N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_67_01_01():
    result = parse("B*67:01:01")
    assert result.__class__ is Allele, f'Expected parse("B*67:01:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*67:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_67_01_02():
    result = parse("B*67:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*67:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*67:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_67_01_03():
    result = parse("B*67:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*67:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*67:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_67_02_01_01():
    result = parse("B*67:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*67:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*67:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_67_02_01_02():
    result = parse("B*67:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*67:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*67:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_67_03():
    result = parse("B*67:03")
    assert result.__class__ is Allele, f'Expected parse("B*67:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*67:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_67_04():
    result = parse("B*67:04")
    assert result.__class__ is Allele, f'Expected parse("B*67:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*67:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_67_05():
    result = parse("B*67:05")
    assert result.__class__ is Allele, f'Expected parse("B*67:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*67:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_67_06():
    result = parse("B*67:06")
    assert result.__class__ is Allele, f'Expected parse("B*67:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*67:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_67_07():
    result = parse("B*67:07")
    assert result.__class__ is Allele, f'Expected parse("B*67:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*67:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_73_01_01_01():
    result = parse("B*73:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*73:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*73:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_73_01_01_02():
    result = parse("B*73:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*73:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*73:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_73_02():
    result = parse("B*73:02")
    assert result.__class__ is Allele, f'Expected parse("B*73:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*73:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_78_01_01_02():
    result = parse("B*78:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*78:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*78:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_78_01_01_03():
    result = parse("B*78:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*78:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*78:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_78_01_02():
    result = parse("B*78:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*78:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*78:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_78_02_01():
    result = parse("B*78:02:01")
    assert result.__class__ is Allele, f'Expected parse("B*78:02:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*78:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_78_02_02():
    result = parse("B*78:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*78:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*78:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_78_03():
    result = parse("B*78:03")
    assert result.__class__ is Allele, f'Expected parse("B*78:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*78:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_78_04():
    result = parse("B*78:04")
    assert result.__class__ is Allele, f'Expected parse("B*78:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*78:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_78_05():
    result = parse("B*78:05")
    assert result.__class__ is Allele, f'Expected parse("B*78:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*78:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_78_06():
    result = parse("B*78:06")
    assert result.__class__ is Allele, f'Expected parse("B*78:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*78:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_78_07():
    result = parse("B*78:07")
    assert result.__class__ is Allele, f'Expected parse("B*78:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*78:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_78_08():
    result = parse("B*78:08")
    assert result.__class__ is Allele, f'Expected parse("B*78:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*78:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_78_09():
    result = parse("B*78:09")
    assert result.__class__ is Allele, f'Expected parse("B*78:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*78:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_78_10():
    result = parse("B*78:10")
    assert result.__class__ is Allele, f'Expected parse("B*78:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*78:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_81_01_01_01():
    result = parse("B*81:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*81:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*81:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_81_01_01_02():
    result = parse("B*81:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*81:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*81:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_81_01_01_03():
    result = parse("B*81:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("B*81:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*81:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_81_01_02():
    result = parse("B*81:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*81:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*81:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_81_01_03():
    result = parse("B*81:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*81:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*81:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_81_01_04():
    result = parse("B*81:01:04")
    assert result.__class__ is Allele, f'Expected parse("B*81:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*81:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_81_01_05():
    result = parse("B*81:01:05")
    assert result.__class__ is Allele, f'Expected parse("B*81:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*81:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_81_02():
    result = parse("B*81:02")
    assert result.__class__ is Allele, f'Expected parse("B*81:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*81:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_81_03():
    result = parse("B*81:03")
    assert result.__class__ is Allele, f'Expected parse("B*81:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*81:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_81_04N():
    result = parse("B*81:04N")
    assert result.__class__ is Allele, f'Expected parse("B*81:04N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*81:04N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_81_05():
    result = parse("B*81:05")
    assert result.__class__ is Allele, f'Expected parse("B*81:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*81:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_81_06():
    result = parse("B*81:06")
    assert result.__class__ is Allele, f'Expected parse("B*81:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*81:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_81_07():
    result = parse("B*81:07")
    assert result.__class__ is Allele, f'Expected parse("B*81:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*81:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_81_08():
    result = parse("B*81:08")
    assert result.__class__ is Allele, f'Expected parse("B*81:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*81:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_81_09():
    result = parse("B*81:09")
    assert result.__class__ is Allele, f'Expected parse("B*81:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*81:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_81_10():
    result = parse("B*81:10")
    assert result.__class__ is Allele, f'Expected parse("B*81:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*81:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_82_01_01_01():
    result = parse("B*82:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*82:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*82:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_82_01_01_02():
    result = parse("B*82:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*82:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*82:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_82_01_02():
    result = parse("B*82:01:02")
    assert result.__class__ is Allele, f'Expected parse("B*82:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*82:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_82_01_03():
    result = parse("B*82:01:03")
    assert result.__class__ is Allele, f'Expected parse("B*82:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*82:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_82_02_01_01():
    result = parse("B*82:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("B*82:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*82:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_82_02_01_02():
    result = parse("B*82:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("B*82:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("B*82:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_82_02_02():
    result = parse("B*82:02:02")
    assert result.__class__ is Allele, f'Expected parse("B*82:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("B*82:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_82_03():
    result = parse("B*82:03")
    assert result.__class__ is Allele, f'Expected parse("B*82:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*82:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_82_04():
    result = parse("B*82:04")
    assert result.__class__ is Allele, f'Expected parse("B*82:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*82:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_B_83_01():
    result = parse("B*83:01")
    assert result.__class__ is Allele, f'Expected parse("B*83:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("B*83:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_01():
    result = parse("C*01:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_02():
    result = parse("C*01:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_03():
    result = parse("C*01:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_04():
    result = parse("C*01:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_05():
    result = parse("C*01:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_06():
    result = parse("C*01:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_07():
    result = parse("C*01:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_08():
    result = parse("C*01:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_09():
    result = parse("C*01:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_10():
    result = parse("C*01:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_11():
    result = parse("C*01:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_12():
    result = parse("C*01:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_13():
    result = parse("C*01:02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_14():
    result = parse("C*01:02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_15():
    result = parse("C*01:02:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_16():
    result = parse("C*01:02:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_17():
    result = parse("C*01:02:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_18():
    result = parse("C*01:02:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_19():
    result = parse("C*01:02:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_20():
    result = parse("C*01:02:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_21():
    result = parse("C*01:02:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_22():
    result = parse("C*01:02:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_23():
    result = parse("C*01:02:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_24():
    result = parse("C*01:02:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_25():
    result = parse("C*01:02:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_26():
    result = parse("C*01:02:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_27():
    result = parse("C*01:02:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_28():
    result = parse("C*01:02:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_29():
    result = parse("C*01:02:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_30():
    result = parse("C*01:02:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_31():
    result = parse("C*01:02:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_32():
    result = parse("C*01:02:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_33():
    result = parse("C*01:02:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_34():
    result = parse("C*01:02:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_35():
    result = parse("C*01:02:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_36():
    result = parse("C*01:02:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_37():
    result = parse("C*01:02:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_38():
    result = parse("C*01:02:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_39():
    result = parse("C*01:02:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_40():
    result = parse("C*01:02:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_41():
    result = parse("C*01:02:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_42():
    result = parse("C*01:02:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_43():
    result = parse("C*01:02:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_01_44():
    result = parse("C*01:02:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:01:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_02():
    result = parse("C*01:02:02")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_03():
    result = parse("C*01:02:03")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_04():
    result = parse("C*01:02:04")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_05():
    result = parse("C*01:02:05")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_06():
    result = parse("C*01:02:06")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_07():
    result = parse("C*01:02:07")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_08():
    result = parse("C*01:02:08")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_09():
    result = parse("C*01:02:09")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_10():
    result = parse("C*01:02:10")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_11():
    result = parse("C*01:02:11")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_12():
    result = parse("C*01:02:12")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_13():
    result = parse("C*01:02:13")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_14():
    result = parse("C*01:02:14")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_15():
    result = parse("C*01:02:15")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_16():
    result = parse("C*01:02:16")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_17():
    result = parse("C*01:02:17")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_18():
    result = parse("C*01:02:18")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_19():
    result = parse("C*01:02:19")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_20():
    result = parse("C*01:02:20")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_21():
    result = parse("C*01:02:21")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_22():
    result = parse("C*01:02:22")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_23():
    result = parse("C*01:02:23")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_24():
    result = parse("C*01:02:24")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_25():
    result = parse("C*01:02:25")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_26():
    result = parse("C*01:02:26")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_27():
    result = parse("C*01:02:27")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_28():
    result = parse("C*01:02:28")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_29():
    result = parse("C*01:02:29")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_30_01():
    result = parse("C*01:02:30:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:30:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:30:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_30_02():
    result = parse("C*01:02:30:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:02:30:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*01:02:30:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_31():
    result = parse("C*01:02:31")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_32():
    result = parse("C*01:02:32")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_33():
    result = parse("C*01:02:33")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_34():
    result = parse("C*01:02:34")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_35():
    result = parse("C*01:02:35")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_36():
    result = parse("C*01:02:36")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_37():
    result = parse("C*01:02:37")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_38():
    result = parse("C*01:02:38")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_39():
    result = parse("C*01:02:39")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_40():
    result = parse("C*01:02:40")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_41():
    result = parse("C*01:02:41")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_42():
    result = parse("C*01:02:42")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_43():
    result = parse("C*01:02:43")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_44():
    result = parse("C*01:02:44")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_45():
    result = parse("C*01:02:45")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_46():
    result = parse("C*01:02:46")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_47():
    result = parse("C*01:02:47")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_48():
    result = parse("C*01:02:48")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_49():
    result = parse("C*01:02:49")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_50():
    result = parse("C*01:02:50")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_51():
    result = parse("C*01:02:51")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_52():
    result = parse("C*01:02:52")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_53():
    result = parse("C*01:02:53")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_54():
    result = parse("C*01:02:54")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_55():
    result = parse("C*01:02:55")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_56():
    result = parse("C*01:02:56")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_57():
    result = parse("C*01:02:57")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_58():
    result = parse("C*01:02:58")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_59():
    result = parse("C*01:02:59")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_60():
    result = parse("C*01:02:60")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_61():
    result = parse("C*01:02:61")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_62():
    result = parse("C*01:02:62")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_63():
    result = parse("C*01:02:63")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_64():
    result = parse("C*01:02:64")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_65():
    result = parse("C*01:02:65")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_66():
    result = parse("C*01:02:66")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:66") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:66") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_67():
    result = parse("C*01:02:67")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:67") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:67") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_02_68():
    result = parse("C*01:02:68")
    assert result.__class__ is Allele, f'Expected parse("C*01:02:68") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:02:68") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_03_01():
    result = parse("C*01:03:01")
    assert result.__class__ is Allele, f'Expected parse("C*01:03:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:03:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_03_02():
    result = parse("C*01:03:02")
    assert result.__class__ is Allele, f'Expected parse("C*01:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_04():
    result = parse("C*01:04")
    assert result.__class__ is Allele, f'Expected parse("C*01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_05():
    result = parse("C*01:05")
    assert result.__class__ is Allele, f'Expected parse("C*01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_06():
    result = parse("C*01:06")
    assert result.__class__ is Allele, f'Expected parse("C*01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_07_01():
    result = parse("C*01:07:01")
    assert result.__class__ is Allele, f'Expected parse("C*01:07:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_07_02():
    result = parse("C*01:07:02")
    assert result.__class__ is Allele, f'Expected parse("C*01:07:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_08():
    result = parse("C*01:08")
    assert result.__class__ is Allele, f'Expected parse("C*01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_09_01():
    result = parse("C*01:09:01")
    assert result.__class__ is Allele, f'Expected parse("C*01:09:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:09:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_09_02():
    result = parse("C*01:09:02")
    assert result.__class__ is Allele, f'Expected parse("C*01:09:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:09:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_10():
    result = parse("C*01:10")
    assert result.__class__ is Allele, f'Expected parse("C*01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_100():
    result = parse("C*01:100")
    assert result.__class__ is Allele, f'Expected parse("C*01:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_101():
    result = parse("C*01:101")
    assert result.__class__ is Allele, f'Expected parse("C*01:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_102():
    result = parse("C*01:102")
    assert result.__class__ is Allele, f'Expected parse("C*01:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_103():
    result = parse("C*01:103")
    assert result.__class__ is Allele, f'Expected parse("C*01:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_104():
    result = parse("C*01:104")
    assert result.__class__ is Allele, f'Expected parse("C*01:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_105():
    result = parse("C*01:105")
    assert result.__class__ is Allele, f'Expected parse("C*01:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_106():
    result = parse("C*01:106")
    assert result.__class__ is Allele, f'Expected parse("C*01:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_107():
    result = parse("C*01:107")
    assert result.__class__ is Allele, f'Expected parse("C*01:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_108():
    result = parse("C*01:108")
    assert result.__class__ is Allele, f'Expected parse("C*01:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_109N():
    result = parse("C*01:109N")
    assert result.__class__ is Allele, f'Expected parse("C*01:109N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:109N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_11():
    result = parse("C*01:11")
    assert result.__class__ is Allele, f'Expected parse("C*01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_110():
    result = parse("C*01:110")
    assert result.__class__ is Allele, f'Expected parse("C*01:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_111N():
    result = parse("C*01:111N")
    assert result.__class__ is Allele, f'Expected parse("C*01:111N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:111N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_112():
    result = parse("C*01:112")
    assert result.__class__ is Allele, f'Expected parse("C*01:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_113():
    result = parse("C*01:113")
    assert result.__class__ is Allele, f'Expected parse("C*01:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_114_01():
    result = parse("C*01:114:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:114:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:114:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_114_02():
    result = parse("C*01:114:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:114:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:114:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_115():
    result = parse("C*01:115")
    assert result.__class__ is Allele, f'Expected parse("C*01:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_116():
    result = parse("C*01:116")
    assert result.__class__ is Allele, f'Expected parse("C*01:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_117N():
    result = parse("C*01:117N")
    assert result.__class__ is Allele, f'Expected parse("C*01:117N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:117N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_118():
    result = parse("C*01:118")
    assert result.__class__ is Allele, f'Expected parse("C*01:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_119():
    result = parse("C*01:119")
    assert result.__class__ is Allele, f'Expected parse("C*01:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_120():
    result = parse("C*01:120")
    assert result.__class__ is Allele, f'Expected parse("C*01:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_121Q():
    result = parse("C*01:121Q")
    assert result.__class__ is Allele, f'Expected parse("C*01:121Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:121Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_122():
    result = parse("C*01:122")
    assert result.__class__ is Allele, f'Expected parse("C*01:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_123():
    result = parse("C*01:123")
    assert result.__class__ is Allele, f'Expected parse("C*01:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_124():
    result = parse("C*01:124")
    assert result.__class__ is Allele, f'Expected parse("C*01:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_125():
    result = parse("C*01:125")
    assert result.__class__ is Allele, f'Expected parse("C*01:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_126():
    result = parse("C*01:126")
    assert result.__class__ is Allele, f'Expected parse("C*01:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_127():
    result = parse("C*01:127")
    assert result.__class__ is Allele, f'Expected parse("C*01:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_128():
    result = parse("C*01:128")
    assert result.__class__ is Allele, f'Expected parse("C*01:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_129():
    result = parse("C*01:129")
    assert result.__class__ is Allele, f'Expected parse("C*01:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_12_01():
    result = parse("C*01:12:01")
    assert result.__class__ is Allele, f'Expected parse("C*01:12:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:12:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_12_02():
    result = parse("C*01:12:02")
    assert result.__class__ is Allele, f'Expected parse("C*01:12:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:12:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_13():
    result = parse("C*01:13")
    assert result.__class__ is Allele, f'Expected parse("C*01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_130():
    result = parse("C*01:130")
    assert result.__class__ is Allele, f'Expected parse("C*01:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_131():
    result = parse("C*01:131")
    assert result.__class__ is Allele, f'Expected parse("C*01:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_132():
    result = parse("C*01:132")
    assert result.__class__ is Allele, f'Expected parse("C*01:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_133():
    result = parse("C*01:133")
    assert result.__class__ is Allele, f'Expected parse("C*01:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_134():
    result = parse("C*01:134")
    assert result.__class__ is Allele, f'Expected parse("C*01:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_135():
    result = parse("C*01:135")
    assert result.__class__ is Allele, f'Expected parse("C*01:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_136():
    result = parse("C*01:136")
    assert result.__class__ is Allele, f'Expected parse("C*01:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_137N():
    result = parse("C*01:137N")
    assert result.__class__ is Allele, f'Expected parse("C*01:137N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:137N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_138():
    result = parse("C*01:138")
    assert result.__class__ is Allele, f'Expected parse("C*01:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_139():
    result = parse("C*01:139")
    assert result.__class__ is Allele, f'Expected parse("C*01:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_14():
    result = parse("C*01:14")
    assert result.__class__ is Allele, f'Expected parse("C*01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_140():
    result = parse("C*01:140")
    assert result.__class__ is Allele, f'Expected parse("C*01:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_141():
    result = parse("C*01:141")
    assert result.__class__ is Allele, f'Expected parse("C*01:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_142():
    result = parse("C*01:142")
    assert result.__class__ is Allele, f'Expected parse("C*01:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_143N():
    result = parse("C*01:143N")
    assert result.__class__ is Allele, f'Expected parse("C*01:143N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:143N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_144():
    result = parse("C*01:144")
    assert result.__class__ is Allele, f'Expected parse("C*01:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_145_01N():
    result = parse("C*01:145:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:145:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:145:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_145_02N():
    result = parse("C*01:145:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:145:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:145:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_146_01():
    result = parse("C*01:146:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:146:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:146:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_146_02():
    result = parse("C*01:146:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:146:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:146:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_147():
    result = parse("C*01:147")
    assert result.__class__ is Allele, f'Expected parse("C*01:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_148():
    result = parse("C*01:148")
    assert result.__class__ is Allele, f'Expected parse("C*01:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_149():
    result = parse("C*01:149")
    assert result.__class__ is Allele, f'Expected parse("C*01:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_150():
    result = parse("C*01:150")
    assert result.__class__ is Allele, f'Expected parse("C*01:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_151():
    result = parse("C*01:151")
    assert result.__class__ is Allele, f'Expected parse("C*01:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_152():
    result = parse("C*01:152")
    assert result.__class__ is Allele, f'Expected parse("C*01:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_153():
    result = parse("C*01:153")
    assert result.__class__ is Allele, f'Expected parse("C*01:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_154():
    result = parse("C*01:154")
    assert result.__class__ is Allele, f'Expected parse("C*01:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_155():
    result = parse("C*01:155")
    assert result.__class__ is Allele, f'Expected parse("C*01:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_156():
    result = parse("C*01:156")
    assert result.__class__ is Allele, f'Expected parse("C*01:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_157():
    result = parse("C*01:157")
    assert result.__class__ is Allele, f'Expected parse("C*01:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_158():
    result = parse("C*01:158")
    assert result.__class__ is Allele, f'Expected parse("C*01:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_159():
    result = parse("C*01:159")
    assert result.__class__ is Allele, f'Expected parse("C*01:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_15_01():
    result = parse("C*01:15:01")
    assert result.__class__ is Allele, f'Expected parse("C*01:15:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:15:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_15_02():
    result = parse("C*01:15:02")
    assert result.__class__ is Allele, f'Expected parse("C*01:15:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:15:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_16():
    result = parse("C*01:16")
    assert result.__class__ is Allele, f'Expected parse("C*01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_160():
    result = parse("C*01:160")
    assert result.__class__ is Allele, f'Expected parse("C*01:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_161():
    result = parse("C*01:161")
    assert result.__class__ is Allele, f'Expected parse("C*01:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_162():
    result = parse("C*01:162")
    assert result.__class__ is Allele, f'Expected parse("C*01:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_163():
    result = parse("C*01:163")
    assert result.__class__ is Allele, f'Expected parse("C*01:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_164():
    result = parse("C*01:164")
    assert result.__class__ is Allele, f'Expected parse("C*01:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_165():
    result = parse("C*01:165")
    assert result.__class__ is Allele, f'Expected parse("C*01:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_166():
    result = parse("C*01:166")
    assert result.__class__ is Allele, f'Expected parse("C*01:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_167():
    result = parse("C*01:167")
    assert result.__class__ is Allele, f'Expected parse("C*01:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_168():
    result = parse("C*01:168")
    assert result.__class__ is Allele, f'Expected parse("C*01:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_169_01():
    result = parse("C*01:169:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:169:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:169:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_169_02():
    result = parse("C*01:169:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*01:169:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:169:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_17():
    result = parse("C*01:17")
    assert result.__class__ is Allele, f'Expected parse("C*01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_170():
    result = parse("C*01:170")
    assert result.__class__ is Allele, f'Expected parse("C*01:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_171N():
    result = parse("C*01:171N")
    assert result.__class__ is Allele, f'Expected parse("C*01:171N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:171N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_172():
    result = parse("C*01:172")
    assert result.__class__ is Allele, f'Expected parse("C*01:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_173():
    result = parse("C*01:173")
    assert result.__class__ is Allele, f'Expected parse("C*01:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_174():
    result = parse("C*01:174")
    assert result.__class__ is Allele, f'Expected parse("C*01:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_175():
    result = parse("C*01:175")
    assert result.__class__ is Allele, f'Expected parse("C*01:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_176():
    result = parse("C*01:176")
    assert result.__class__ is Allele, f'Expected parse("C*01:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_177():
    result = parse("C*01:177")
    assert result.__class__ is Allele, f'Expected parse("C*01:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_178():
    result = parse("C*01:178")
    assert result.__class__ is Allele, f'Expected parse("C*01:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_179():
    result = parse("C*01:179")
    assert result.__class__ is Allele, f'Expected parse("C*01:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_18():
    result = parse("C*01:18")
    assert result.__class__ is Allele, f'Expected parse("C*01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_180():
    result = parse("C*01:180")
    assert result.__class__ is Allele, f'Expected parse("C*01:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_181N():
    result = parse("C*01:181N")
    assert result.__class__ is Allele, f'Expected parse("C*01:181N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:181N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_182():
    result = parse("C*01:182")
    assert result.__class__ is Allele, f'Expected parse("C*01:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_183():
    result = parse("C*01:183")
    assert result.__class__ is Allele, f'Expected parse("C*01:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_184():
    result = parse("C*01:184")
    assert result.__class__ is Allele, f'Expected parse("C*01:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_185Q():
    result = parse("C*01:185Q")
    assert result.__class__ is Allele, f'Expected parse("C*01:185Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:185Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_186():
    result = parse("C*01:186")
    assert result.__class__ is Allele, f'Expected parse("C*01:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_187():
    result = parse("C*01:187")
    assert result.__class__ is Allele, f'Expected parse("C*01:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_188():
    result = parse("C*01:188")
    assert result.__class__ is Allele, f'Expected parse("C*01:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_189():
    result = parse("C*01:189")
    assert result.__class__ is Allele, f'Expected parse("C*01:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_19():
    result = parse("C*01:19")
    assert result.__class__ is Allele, f'Expected parse("C*01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_190():
    result = parse("C*01:190")
    assert result.__class__ is Allele, f'Expected parse("C*01:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_191():
    result = parse("C*01:191")
    assert result.__class__ is Allele, f'Expected parse("C*01:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_192():
    result = parse("C*01:192")
    assert result.__class__ is Allele, f'Expected parse("C*01:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_193():
    result = parse("C*01:193")
    assert result.__class__ is Allele, f'Expected parse("C*01:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_194():
    result = parse("C*01:194")
    assert result.__class__ is Allele, f'Expected parse("C*01:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_195():
    result = parse("C*01:195")
    assert result.__class__ is Allele, f'Expected parse("C*01:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_196():
    result = parse("C*01:196")
    assert result.__class__ is Allele, f'Expected parse("C*01:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_197():
    result = parse("C*01:197")
    assert result.__class__ is Allele, f'Expected parse("C*01:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_20():
    result = parse("C*01:20")
    assert result.__class__ is Allele, f'Expected parse("C*01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_21():
    result = parse("C*01:21")
    assert result.__class__ is Allele, f'Expected parse("C*01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_22():
    result = parse("C*01:22")
    assert result.__class__ is Allele, f'Expected parse("C*01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_23():
    result = parse("C*01:23")
    assert result.__class__ is Allele, f'Expected parse("C*01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_24():
    result = parse("C*01:24")
    assert result.__class__ is Allele, f'Expected parse("C*01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_25():
    result = parse("C*01:25")
    assert result.__class__ is Allele, f'Expected parse("C*01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_26():
    result = parse("C*01:26")
    assert result.__class__ is Allele, f'Expected parse("C*01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_27():
    result = parse("C*01:27")
    assert result.__class__ is Allele, f'Expected parse("C*01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_28():
    result = parse("C*01:28")
    assert result.__class__ is Allele, f'Expected parse("C*01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_29():
    result = parse("C*01:29")
    assert result.__class__ is Allele, f'Expected parse("C*01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_30():
    result = parse("C*01:30")
    assert result.__class__ is Allele, f'Expected parse("C*01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_31():
    result = parse("C*01:31")
    assert result.__class__ is Allele, f'Expected parse("C*01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_32_01():
    result = parse("C*01:32:01")
    assert result.__class__ is Allele, f'Expected parse("C*01:32:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:32:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_32_02():
    result = parse("C*01:32:02")
    assert result.__class__ is Allele, f'Expected parse("C*01:32:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:32:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_33():
    result = parse("C*01:33")
    assert result.__class__ is Allele, f'Expected parse("C*01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_34():
    result = parse("C*01:34")
    assert result.__class__ is Allele, f'Expected parse("C*01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_35():
    result = parse("C*01:35")
    assert result.__class__ is Allele, f'Expected parse("C*01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_36_01():
    result = parse("C*01:36:01")
    assert result.__class__ is Allele, f'Expected parse("C*01:36:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:36:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_36_02():
    result = parse("C*01:36:02")
    assert result.__class__ is Allele, f'Expected parse("C*01:36:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:36:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_37N():
    result = parse("C*01:37N")
    assert result.__class__ is Allele, f'Expected parse("C*01:37N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:37N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_38():
    result = parse("C*01:38")
    assert result.__class__ is Allele, f'Expected parse("C*01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_39():
    result = parse("C*01:39")
    assert result.__class__ is Allele, f'Expected parse("C*01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_40():
    result = parse("C*01:40")
    assert result.__class__ is Allele, f'Expected parse("C*01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_41():
    result = parse("C*01:41")
    assert result.__class__ is Allele, f'Expected parse("C*01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_42():
    result = parse("C*01:42")
    assert result.__class__ is Allele, f'Expected parse("C*01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_43():
    result = parse("C*01:43")
    assert result.__class__ is Allele, f'Expected parse("C*01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_44():
    result = parse("C*01:44")
    assert result.__class__ is Allele, f'Expected parse("C*01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_45():
    result = parse("C*01:45")
    assert result.__class__ is Allele, f'Expected parse("C*01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_46():
    result = parse("C*01:46")
    assert result.__class__ is Allele, f'Expected parse("C*01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_47():
    result = parse("C*01:47")
    assert result.__class__ is Allele, f'Expected parse("C*01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_48():
    result = parse("C*01:48")
    assert result.__class__ is Allele, f'Expected parse("C*01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_49_01():
    result = parse("C*01:49:01")
    assert result.__class__ is Allele, f'Expected parse("C*01:49:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:49:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_49_02():
    result = parse("C*01:49:02")
    assert result.__class__ is Allele, f'Expected parse("C*01:49:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:49:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_50():
    result = parse("C*01:50")
    assert result.__class__ is Allele, f'Expected parse("C*01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_51():
    result = parse("C*01:51")
    assert result.__class__ is Allele, f'Expected parse("C*01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_52():
    result = parse("C*01:52")
    assert result.__class__ is Allele, f'Expected parse("C*01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_53():
    result = parse("C*01:53")
    assert result.__class__ is Allele, f'Expected parse("C*01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_54():
    result = parse("C*01:54")
    assert result.__class__ is Allele, f'Expected parse("C*01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_55():
    result = parse("C*01:55")
    assert result.__class__ is Allele, f'Expected parse("C*01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_56N():
    result = parse("C*01:56N")
    assert result.__class__ is Allele, f'Expected parse("C*01:56N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:56N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_57():
    result = parse("C*01:57")
    assert result.__class__ is Allele, f'Expected parse("C*01:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_58():
    result = parse("C*01:58")
    assert result.__class__ is Allele, f'Expected parse("C*01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_59():
    result = parse("C*01:59")
    assert result.__class__ is Allele, f'Expected parse("C*01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_60():
    result = parse("C*01:60")
    assert result.__class__ is Allele, f'Expected parse("C*01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_61():
    result = parse("C*01:61")
    assert result.__class__ is Allele, f'Expected parse("C*01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_62():
    result = parse("C*01:62")
    assert result.__class__ is Allele, f'Expected parse("C*01:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_63_02():
    result = parse("C*01:63:02")
    assert result.__class__ is Allele, f'Expected parse("C*01:63:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:63:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_64():
    result = parse("C*01:64")
    assert result.__class__ is Allele, f'Expected parse("C*01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_65():
    result = parse("C*01:65")
    assert result.__class__ is Allele, f'Expected parse("C*01:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_66():
    result = parse("C*01:66")
    assert result.__class__ is Allele, f'Expected parse("C*01:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_67():
    result = parse("C*01:67")
    assert result.__class__ is Allele, f'Expected parse("C*01:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_68():
    result = parse("C*01:68")
    assert result.__class__ is Allele, f'Expected parse("C*01:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_69N():
    result = parse("C*01:69N")
    assert result.__class__ is Allele, f'Expected parse("C*01:69N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:69N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_70():
    result = parse("C*01:70")
    assert result.__class__ is Allele, f'Expected parse("C*01:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_71():
    result = parse("C*01:71")
    assert result.__class__ is Allele, f'Expected parse("C*01:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_72():
    result = parse("C*01:72")
    assert result.__class__ is Allele, f'Expected parse("C*01:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_73():
    result = parse("C*01:73")
    assert result.__class__ is Allele, f'Expected parse("C*01:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_74():
    result = parse("C*01:74")
    assert result.__class__ is Allele, f'Expected parse("C*01:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_75():
    result = parse("C*01:75")
    assert result.__class__ is Allele, f'Expected parse("C*01:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_76():
    result = parse("C*01:76")
    assert result.__class__ is Allele, f'Expected parse("C*01:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_77():
    result = parse("C*01:77")
    assert result.__class__ is Allele, f'Expected parse("C*01:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_78():
    result = parse("C*01:78")
    assert result.__class__ is Allele, f'Expected parse("C*01:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_79_01():
    result = parse("C*01:79:01")
    assert result.__class__ is Allele, f'Expected parse("C*01:79:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:79:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_79_02():
    result = parse("C*01:79:02")
    assert result.__class__ is Allele, f'Expected parse("C*01:79:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*01:79:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_80():
    result = parse("C*01:80")
    assert result.__class__ is Allele, f'Expected parse("C*01:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_81():
    result = parse("C*01:81")
    assert result.__class__ is Allele, f'Expected parse("C*01:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_82():
    result = parse("C*01:82")
    assert result.__class__ is Allele, f'Expected parse("C*01:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_83():
    result = parse("C*01:83")
    assert result.__class__ is Allele, f'Expected parse("C*01:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_84():
    result = parse("C*01:84")
    assert result.__class__ is Allele, f'Expected parse("C*01:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_85():
    result = parse("C*01:85")
    assert result.__class__ is Allele, f'Expected parse("C*01:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_86N():
    result = parse("C*01:86N")
    assert result.__class__ is Allele, f'Expected parse("C*01:86N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:86N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_87():
    result = parse("C*01:87")
    assert result.__class__ is Allele, f'Expected parse("C*01:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_88():
    result = parse("C*01:88")
    assert result.__class__ is Allele, f'Expected parse("C*01:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_89N():
    result = parse("C*01:89N")
    assert result.__class__ is Allele, f'Expected parse("C*01:89N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:89N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_90():
    result = parse("C*01:90")
    assert result.__class__ is Allele, f'Expected parse("C*01:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_91():
    result = parse("C*01:91")
    assert result.__class__ is Allele, f'Expected parse("C*01:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_92():
    result = parse("C*01:92")
    assert result.__class__ is Allele, f'Expected parse("C*01:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_93():
    result = parse("C*01:93")
    assert result.__class__ is Allele, f'Expected parse("C*01:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_94():
    result = parse("C*01:94")
    assert result.__class__ is Allele, f'Expected parse("C*01:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_95():
    result = parse("C*01:95")
    assert result.__class__ is Allele, f'Expected parse("C*01:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_96():
    result = parse("C*01:96")
    assert result.__class__ is Allele, f'Expected parse("C*01:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_97():
    result = parse("C*01:97")
    assert result.__class__ is Allele, f'Expected parse("C*01:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_98N():
    result = parse("C*01:98N")
    assert result.__class__ is Allele, f'Expected parse("C*01:98N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:98N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_01_99():
    result = parse("C*01:99")
    assert result.__class__ is Allele, f'Expected parse("C*01:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*01:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_01():
    result = parse("C*02:02:01")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_01():
    result = parse("C*02:02:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_02():
    result = parse("C*02:02:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_03():
    result = parse("C*02:02:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_04():
    result = parse("C*02:02:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_05():
    result = parse("C*02:02:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_06():
    result = parse("C*02:02:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_07():
    result = parse("C*02:02:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_08():
    result = parse("C*02:02:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_09():
    result = parse("C*02:02:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_10():
    result = parse("C*02:02:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_11():
    result = parse("C*02:02:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_12():
    result = parse("C*02:02:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_13():
    result = parse("C*02:02:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_14():
    result = parse("C*02:02:02:14")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_15():
    result = parse("C*02:02:02:15")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_16():
    result = parse("C*02:02:02:16")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_17():
    result = parse("C*02:02:02:17")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_18():
    result = parse("C*02:02:02:18")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_19():
    result = parse("C*02:02:02:19")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_20():
    result = parse("C*02:02:02:20")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_21():
    result = parse("C*02:02:02:21")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_22():
    result = parse("C*02:02:02:22")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_23():
    result = parse("C*02:02:02:23")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_24():
    result = parse("C*02:02:02:24")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_25():
    result = parse("C*02:02:02:25")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_26():
    result = parse("C*02:02:02:26")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_27():
    result = parse("C*02:02:02:27")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_28():
    result = parse("C*02:02:02:28")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_29():
    result = parse("C*02:02:02:29")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_30():
    result = parse("C*02:02:02:30")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_31():
    result = parse("C*02:02:02:31")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_32():
    result = parse("C*02:02:02:32")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_33():
    result = parse("C*02:02:02:33")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_34Q():
    result = parse("C*02:02:02:34Q")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:34Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:34Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_35():
    result = parse("C*02:02:02:35")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_36():
    result = parse("C*02:02:02:36")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_37():
    result = parse("C*02:02:02:37")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_38():
    result = parse("C*02:02:02:38")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_39():
    result = parse("C*02:02:02:39")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_40():
    result = parse("C*02:02:02:40")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_41():
    result = parse("C*02:02:02:41")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_42():
    result = parse("C*02:02:02:42")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_02_43():
    result = parse("C*02:02:02:43")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:02:02:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:02:02:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_03():
    result = parse("C*02:02:03")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_06():
    result = parse("C*02:02:06")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_07():
    result = parse("C*02:02:07")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_08():
    result = parse("C*02:02:08")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_09():
    result = parse("C*02:02:09")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_10():
    result = parse("C*02:02:10")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_11():
    result = parse("C*02:02:11")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_12():
    result = parse("C*02:02:12")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_13():
    result = parse("C*02:02:13")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_14():
    result = parse("C*02:02:14")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_15():
    result = parse("C*02:02:15")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_16():
    result = parse("C*02:02:16")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_17():
    result = parse("C*02:02:17")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_18():
    result = parse("C*02:02:18")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_19():
    result = parse("C*02:02:19")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_20():
    result = parse("C*02:02:20")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_21():
    result = parse("C*02:02:21")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_22():
    result = parse("C*02:02:22")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_23():
    result = parse("C*02:02:23")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_24():
    result = parse("C*02:02:24")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_25():
    result = parse("C*02:02:25")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_26():
    result = parse("C*02:02:26")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_27():
    result = parse("C*02:02:27")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_28():
    result = parse("C*02:02:28")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_29():
    result = parse("C*02:02:29")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_30():
    result = parse("C*02:02:30")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_31():
    result = parse("C*02:02:31")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_32():
    result = parse("C*02:02:32")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_33():
    result = parse("C*02:02:33")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_34():
    result = parse("C*02:02:34")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_35():
    result = parse("C*02:02:35")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_36():
    result = parse("C*02:02:36")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_37():
    result = parse("C*02:02:37")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_38():
    result = parse("C*02:02:38")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_39():
    result = parse("C*02:02:39")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_40():
    result = parse("C*02:02:40")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_41():
    result = parse("C*02:02:41")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_42():
    result = parse("C*02:02:42")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_43():
    result = parse("C*02:02:43")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_44():
    result = parse("C*02:02:44")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_45():
    result = parse("C*02:02:45")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_46():
    result = parse("C*02:02:46")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_47():
    result = parse("C*02:02:47")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_48():
    result = parse("C*02:02:48")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_49():
    result = parse("C*02:02:49")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_50():
    result = parse("C*02:02:50")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_51():
    result = parse("C*02:02:51")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_52():
    result = parse("C*02:02:52")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_53():
    result = parse("C*02:02:53")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_54():
    result = parse("C*02:02:54")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_55():
    result = parse("C*02:02:55")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_56():
    result = parse("C*02:02:56")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_57():
    result = parse("C*02:02:57")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_58():
    result = parse("C*02:02:58")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_02_59():
    result = parse("C*02:02:59")
    assert result.__class__ is Allele, f'Expected parse("C*02:02:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:02:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_03():
    result = parse("C*02:03")
    assert result.__class__ is Allele, f'Expected parse("C*02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_04():
    result = parse("C*02:04")
    assert result.__class__ is Allele, f'Expected parse("C*02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_05_01():
    result = parse("C*02:05:01")
    assert result.__class__ is Allele, f'Expected parse("C*02:05:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_05_02():
    result = parse("C*02:05:02")
    assert result.__class__ is Allele, f'Expected parse("C*02:05:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_05_03():
    result = parse("C*02:05:03")
    assert result.__class__ is Allele, f'Expected parse("C*02:05:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:05:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_06_01():
    result = parse("C*02:06:01")
    assert result.__class__ is Allele, f'Expected parse("C*02:06:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_06_02():
    result = parse("C*02:06:02")
    assert result.__class__ is Allele, f'Expected parse("C*02:06:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_07():
    result = parse("C*02:07")
    assert result.__class__ is Allele, f'Expected parse("C*02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_08():
    result = parse("C*02:08")
    assert result.__class__ is Allele, f'Expected parse("C*02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_09():
    result = parse("C*02:09")
    assert result.__class__ is Allele, f'Expected parse("C*02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_100():
    result = parse("C*02:100")
    assert result.__class__ is Allele, f'Expected parse("C*02:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_101():
    result = parse("C*02:101")
    assert result.__class__ is Allele, f'Expected parse("C*02:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_102():
    result = parse("C*02:102")
    assert result.__class__ is Allele, f'Expected parse("C*02:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_103():
    result = parse("C*02:103")
    assert result.__class__ is Allele, f'Expected parse("C*02:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_104():
    result = parse("C*02:104")
    assert result.__class__ is Allele, f'Expected parse("C*02:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_105N():
    result = parse("C*02:105N")
    assert result.__class__ is Allele, f'Expected parse("C*02:105N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:105N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_106():
    result = parse("C*02:106")
    assert result.__class__ is Allele, f'Expected parse("C*02:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_107():
    result = parse("C*02:107")
    assert result.__class__ is Allele, f'Expected parse("C*02:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_108():
    result = parse("C*02:108")
    assert result.__class__ is Allele, f'Expected parse("C*02:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_109():
    result = parse("C*02:109")
    assert result.__class__ is Allele, f'Expected parse("C*02:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_01_01():
    result = parse("C*02:10:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:10:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:10:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_01_02():
    result = parse("C*02:10:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:10:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:10:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_01_03():
    result = parse("C*02:10:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:10:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:10:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_01_04():
    result = parse("C*02:10:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:10:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:10:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_01_05():
    result = parse("C*02:10:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:10:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:10:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_01_06():
    result = parse("C*02:10:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:10:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:10:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_01_07():
    result = parse("C*02:10:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:10:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:10:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_01_08():
    result = parse("C*02:10:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:10:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:10:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_01_09():
    result = parse("C*02:10:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:10:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:10:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_01_10():
    result = parse("C*02:10:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:10:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:10:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_01_11():
    result = parse("C*02:10:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:10:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:10:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_01_12():
    result = parse("C*02:10:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:10:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:10:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_01_13():
    result = parse("C*02:10:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:10:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:10:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_01_14():
    result = parse("C*02:10:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:10:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:10:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_01_15():
    result = parse("C*02:10:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:10:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*02:10:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_02():
    result = parse("C*02:10:02")
    assert result.__class__ is Allele, f'Expected parse("C*02:10:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:10:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_03():
    result = parse("C*02:10:03")
    assert result.__class__ is Allele, f'Expected parse("C*02:10:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:10:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_04():
    result = parse("C*02:10:04")
    assert result.__class__ is Allele, f'Expected parse("C*02:10:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:10:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_05():
    result = parse("C*02:10:05")
    assert result.__class__ is Allele, f'Expected parse("C*02:10:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:10:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_06():
    result = parse("C*02:10:06")
    assert result.__class__ is Allele, f'Expected parse("C*02:10:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:10:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_10_07():
    result = parse("C*02:10:07")
    assert result.__class__ is Allele, f'Expected parse("C*02:10:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:10:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_11():
    result = parse("C*02:11")
    assert result.__class__ is Allele, f'Expected parse("C*02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_110():
    result = parse("C*02:110")
    assert result.__class__ is Allele, f'Expected parse("C*02:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_111():
    result = parse("C*02:111")
    assert result.__class__ is Allele, f'Expected parse("C*02:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_112():
    result = parse("C*02:112")
    assert result.__class__ is Allele, f'Expected parse("C*02:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_113():
    result = parse("C*02:113")
    assert result.__class__ is Allele, f'Expected parse("C*02:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_114():
    result = parse("C*02:114")
    assert result.__class__ is Allele, f'Expected parse("C*02:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_115():
    result = parse("C*02:115")
    assert result.__class__ is Allele, f'Expected parse("C*02:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_116():
    result = parse("C*02:116")
    assert result.__class__ is Allele, f'Expected parse("C*02:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_117():
    result = parse("C*02:117")
    assert result.__class__ is Allele, f'Expected parse("C*02:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_118():
    result = parse("C*02:118")
    assert result.__class__ is Allele, f'Expected parse("C*02:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_119():
    result = parse("C*02:119")
    assert result.__class__ is Allele, f'Expected parse("C*02:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_12():
    result = parse("C*02:12")
    assert result.__class__ is Allele, f'Expected parse("C*02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_120():
    result = parse("C*02:120")
    assert result.__class__ is Allele, f'Expected parse("C*02:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_121N():
    result = parse("C*02:121N")
    assert result.__class__ is Allele, f'Expected parse("C*02:121N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:121N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_122():
    result = parse("C*02:122")
    assert result.__class__ is Allele, f'Expected parse("C*02:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_123():
    result = parse("C*02:123")
    assert result.__class__ is Allele, f'Expected parse("C*02:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_124():
    result = parse("C*02:124")
    assert result.__class__ is Allele, f'Expected parse("C*02:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_125():
    result = parse("C*02:125")
    assert result.__class__ is Allele, f'Expected parse("C*02:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_126():
    result = parse("C*02:126")
    assert result.__class__ is Allele, f'Expected parse("C*02:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_127():
    result = parse("C*02:127")
    assert result.__class__ is Allele, f'Expected parse("C*02:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_128():
    result = parse("C*02:128")
    assert result.__class__ is Allele, f'Expected parse("C*02:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_129():
    result = parse("C*02:129")
    assert result.__class__ is Allele, f'Expected parse("C*02:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_13():
    result = parse("C*02:13")
    assert result.__class__ is Allele, f'Expected parse("C*02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_130():
    result = parse("C*02:130")
    assert result.__class__ is Allele, f'Expected parse("C*02:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_131():
    result = parse("C*02:131")
    assert result.__class__ is Allele, f'Expected parse("C*02:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_132():
    result = parse("C*02:132")
    assert result.__class__ is Allele, f'Expected parse("C*02:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_133():
    result = parse("C*02:133")
    assert result.__class__ is Allele, f'Expected parse("C*02:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_134():
    result = parse("C*02:134")
    assert result.__class__ is Allele, f'Expected parse("C*02:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_135N():
    result = parse("C*02:135N")
    assert result.__class__ is Allele, f'Expected parse("C*02:135N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:135N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_136():
    result = parse("C*02:136")
    assert result.__class__ is Allele, f'Expected parse("C*02:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_137():
    result = parse("C*02:137")
    assert result.__class__ is Allele, f'Expected parse("C*02:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_138():
    result = parse("C*02:138")
    assert result.__class__ is Allele, f'Expected parse("C*02:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_139():
    result = parse("C*02:139")
    assert result.__class__ is Allele, f'Expected parse("C*02:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_140():
    result = parse("C*02:140")
    assert result.__class__ is Allele, f'Expected parse("C*02:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_141():
    result = parse("C*02:141")
    assert result.__class__ is Allele, f'Expected parse("C*02:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_142():
    result = parse("C*02:142")
    assert result.__class__ is Allele, f'Expected parse("C*02:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_143():
    result = parse("C*02:143")
    assert result.__class__ is Allele, f'Expected parse("C*02:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_144():
    result = parse("C*02:144")
    assert result.__class__ is Allele, f'Expected parse("C*02:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_145():
    result = parse("C*02:145")
    assert result.__class__ is Allele, f'Expected parse("C*02:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_146():
    result = parse("C*02:146")
    assert result.__class__ is Allele, f'Expected parse("C*02:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_147():
    result = parse("C*02:147")
    assert result.__class__ is Allele, f'Expected parse("C*02:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_148():
    result = parse("C*02:148")
    assert result.__class__ is Allele, f'Expected parse("C*02:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_149():
    result = parse("C*02:149")
    assert result.__class__ is Allele, f'Expected parse("C*02:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_14_01():
    result = parse("C*02:14:01")
    assert result.__class__ is Allele, f'Expected parse("C*02:14:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:14:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_14_02():
    result = parse("C*02:14:02")
    assert result.__class__ is Allele, f'Expected parse("C*02:14:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:14:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_15():
    result = parse("C*02:15")
    assert result.__class__ is Allele, f'Expected parse("C*02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_150N():
    result = parse("C*02:150N")
    assert result.__class__ is Allele, f'Expected parse("C*02:150N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:150N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_151():
    result = parse("C*02:151")
    assert result.__class__ is Allele, f'Expected parse("C*02:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_152():
    result = parse("C*02:152")
    assert result.__class__ is Allele, f'Expected parse("C*02:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_153():
    result = parse("C*02:153")
    assert result.__class__ is Allele, f'Expected parse("C*02:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_154():
    result = parse("C*02:154")
    assert result.__class__ is Allele, f'Expected parse("C*02:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_155():
    result = parse("C*02:155")
    assert result.__class__ is Allele, f'Expected parse("C*02:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_156():
    result = parse("C*02:156")
    assert result.__class__ is Allele, f'Expected parse("C*02:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_157():
    result = parse("C*02:157")
    assert result.__class__ is Allele, f'Expected parse("C*02:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_158():
    result = parse("C*02:158")
    assert result.__class__ is Allele, f'Expected parse("C*02:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_159():
    result = parse("C*02:159")
    assert result.__class__ is Allele, f'Expected parse("C*02:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_160():
    result = parse("C*02:160")
    assert result.__class__ is Allele, f'Expected parse("C*02:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_161():
    result = parse("C*02:161")
    assert result.__class__ is Allele, f'Expected parse("C*02:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_162():
    result = parse("C*02:162")
    assert result.__class__ is Allele, f'Expected parse("C*02:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_163():
    result = parse("C*02:163")
    assert result.__class__ is Allele, f'Expected parse("C*02:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_164():
    result = parse("C*02:164")
    assert result.__class__ is Allele, f'Expected parse("C*02:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_165N():
    result = parse("C*02:165N")
    assert result.__class__ is Allele, f'Expected parse("C*02:165N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:165N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_166():
    result = parse("C*02:166")
    assert result.__class__ is Allele, f'Expected parse("C*02:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_167():
    result = parse("C*02:167")
    assert result.__class__ is Allele, f'Expected parse("C*02:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_168():
    result = parse("C*02:168")
    assert result.__class__ is Allele, f'Expected parse("C*02:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_169N():
    result = parse("C*02:169N")
    assert result.__class__ is Allele, f'Expected parse("C*02:169N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:169N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_16_02():
    result = parse("C*02:16:02")
    assert result.__class__ is Allele, f'Expected parse("C*02:16:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:16:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_17():
    result = parse("C*02:17")
    assert result.__class__ is Allele, f'Expected parse("C*02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_170():
    result = parse("C*02:170")
    assert result.__class__ is Allele, f'Expected parse("C*02:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_171():
    result = parse("C*02:171")
    assert result.__class__ is Allele, f'Expected parse("C*02:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_172():
    result = parse("C*02:172")
    assert result.__class__ is Allele, f'Expected parse("C*02:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_173():
    result = parse("C*02:173")
    assert result.__class__ is Allele, f'Expected parse("C*02:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_174():
    result = parse("C*02:174")
    assert result.__class__ is Allele, f'Expected parse("C*02:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_175():
    result = parse("C*02:175")
    assert result.__class__ is Allele, f'Expected parse("C*02:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_176():
    result = parse("C*02:176")
    assert result.__class__ is Allele, f'Expected parse("C*02:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_177():
    result = parse("C*02:177")
    assert result.__class__ is Allele, f'Expected parse("C*02:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_178():
    result = parse("C*02:178")
    assert result.__class__ is Allele, f'Expected parse("C*02:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_179():
    result = parse("C*02:179")
    assert result.__class__ is Allele, f'Expected parse("C*02:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_18():
    result = parse("C*02:18")
    assert result.__class__ is Allele, f'Expected parse("C*02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_180():
    result = parse("C*02:180")
    assert result.__class__ is Allele, f'Expected parse("C*02:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_181():
    result = parse("C*02:181")
    assert result.__class__ is Allele, f'Expected parse("C*02:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_182():
    result = parse("C*02:182")
    assert result.__class__ is Allele, f'Expected parse("C*02:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_183():
    result = parse("C*02:183")
    assert result.__class__ is Allele, f'Expected parse("C*02:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_184():
    result = parse("C*02:184")
    assert result.__class__ is Allele, f'Expected parse("C*02:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_185():
    result = parse("C*02:185")
    assert result.__class__ is Allele, f'Expected parse("C*02:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_186():
    result = parse("C*02:186")
    assert result.__class__ is Allele, f'Expected parse("C*02:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_187():
    result = parse("C*02:187")
    assert result.__class__ is Allele, f'Expected parse("C*02:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_188():
    result = parse("C*02:188")
    assert result.__class__ is Allele, f'Expected parse("C*02:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_189():
    result = parse("C*02:189")
    assert result.__class__ is Allele, f'Expected parse("C*02:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_19():
    result = parse("C*02:19")
    assert result.__class__ is Allele, f'Expected parse("C*02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_190():
    result = parse("C*02:190")
    assert result.__class__ is Allele, f'Expected parse("C*02:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_191():
    result = parse("C*02:191")
    assert result.__class__ is Allele, f'Expected parse("C*02:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_192N():
    result = parse("C*02:192N")
    assert result.__class__ is Allele, f'Expected parse("C*02:192N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:192N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_20():
    result = parse("C*02:20")
    assert result.__class__ is Allele, f'Expected parse("C*02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_21():
    result = parse("C*02:21")
    assert result.__class__ is Allele, f'Expected parse("C*02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_22():
    result = parse("C*02:22")
    assert result.__class__ is Allele, f'Expected parse("C*02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_23():
    result = parse("C*02:23")
    assert result.__class__ is Allele, f'Expected parse("C*02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_24():
    result = parse("C*02:24")
    assert result.__class__ is Allele, f'Expected parse("C*02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_25Q():
    result = parse("C*02:25Q")
    assert result.__class__ is Allele, f'Expected parse("C*02:25Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:25Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_26_01():
    result = parse("C*02:26:01")
    assert result.__class__ is Allele, f'Expected parse("C*02:26:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:26:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_26_02():
    result = parse("C*02:26:02")
    assert result.__class__ is Allele, f'Expected parse("C*02:26:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:26:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_26_03():
    result = parse("C*02:26:03")
    assert result.__class__ is Allele, f'Expected parse("C*02:26:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:26:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_27_01():
    result = parse("C*02:27:01")
    assert result.__class__ is Allele, f'Expected parse("C*02:27:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:27:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_27_02():
    result = parse("C*02:27:02")
    assert result.__class__ is Allele, f'Expected parse("C*02:27:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:27:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_28():
    result = parse("C*02:28")
    assert result.__class__ is Allele, f'Expected parse("C*02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_29():
    result = parse("C*02:29")
    assert result.__class__ is Allele, f'Expected parse("C*02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_30():
    result = parse("C*02:30")
    assert result.__class__ is Allele, f'Expected parse("C*02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_31():
    result = parse("C*02:31")
    assert result.__class__ is Allele, f'Expected parse("C*02:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_32():
    result = parse("C*02:32")
    assert result.__class__ is Allele, f'Expected parse("C*02:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_33():
    result = parse("C*02:33")
    assert result.__class__ is Allele, f'Expected parse("C*02:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_34():
    result = parse("C*02:34")
    assert result.__class__ is Allele, f'Expected parse("C*02:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_35():
    result = parse("C*02:35")
    assert result.__class__ is Allele, f'Expected parse("C*02:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_36_01():
    result = parse("C*02:36:01")
    assert result.__class__ is Allele, f'Expected parse("C*02:36:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:36:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_36_02():
    result = parse("C*02:36:02")
    assert result.__class__ is Allele, f'Expected parse("C*02:36:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:36:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_37():
    result = parse("C*02:37")
    assert result.__class__ is Allele, f'Expected parse("C*02:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_38_01N():
    result = parse("C*02:38:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:38:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:38:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_38_02N():
    result = parse("C*02:38:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*02:38:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:38:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_39():
    result = parse("C*02:39")
    assert result.__class__ is Allele, f'Expected parse("C*02:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_40_01():
    result = parse("C*02:40:01")
    assert result.__class__ is Allele, f'Expected parse("C*02:40:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:40:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_40_02():
    result = parse("C*02:40:02")
    assert result.__class__ is Allele, f'Expected parse("C*02:40:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:40:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_42():
    result = parse("C*02:42")
    assert result.__class__ is Allele, f'Expected parse("C*02:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_43_01():
    result = parse("C*02:43:01")
    assert result.__class__ is Allele, f'Expected parse("C*02:43:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:43:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_43_02():
    result = parse("C*02:43:02")
    assert result.__class__ is Allele, f'Expected parse("C*02:43:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:43:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_44():
    result = parse("C*02:44")
    assert result.__class__ is Allele, f'Expected parse("C*02:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_45():
    result = parse("C*02:45")
    assert result.__class__ is Allele, f'Expected parse("C*02:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_46():
    result = parse("C*02:46")
    assert result.__class__ is Allele, f'Expected parse("C*02:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_47():
    result = parse("C*02:47")
    assert result.__class__ is Allele, f'Expected parse("C*02:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_48():
    result = parse("C*02:48")
    assert result.__class__ is Allele, f'Expected parse("C*02:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_49():
    result = parse("C*02:49")
    assert result.__class__ is Allele, f'Expected parse("C*02:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_50():
    result = parse("C*02:50")
    assert result.__class__ is Allele, f'Expected parse("C*02:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_51():
    result = parse("C*02:51")
    assert result.__class__ is Allele, f'Expected parse("C*02:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_52N():
    result = parse("C*02:52N")
    assert result.__class__ is Allele, f'Expected parse("C*02:52N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:52N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_53_01():
    result = parse("C*02:53:01")
    assert result.__class__ is Allele, f'Expected parse("C*02:53:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:53:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_53_02():
    result = parse("C*02:53:02")
    assert result.__class__ is Allele, f'Expected parse("C*02:53:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:53:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_54():
    result = parse("C*02:54")
    assert result.__class__ is Allele, f'Expected parse("C*02:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_55_01():
    result = parse("C*02:55:01")
    assert result.__class__ is Allele, f'Expected parse("C*02:55:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:55:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_55_02():
    result = parse("C*02:55:02")
    assert result.__class__ is Allele, f'Expected parse("C*02:55:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:55:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_56():
    result = parse("C*02:56")
    assert result.__class__ is Allele, f'Expected parse("C*02:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_57():
    result = parse("C*02:57")
    assert result.__class__ is Allele, f'Expected parse("C*02:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_58():
    result = parse("C*02:58")
    assert result.__class__ is Allele, f'Expected parse("C*02:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_59():
    result = parse("C*02:59")
    assert result.__class__ is Allele, f'Expected parse("C*02:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_60():
    result = parse("C*02:60")
    assert result.__class__ is Allele, f'Expected parse("C*02:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_61_01():
    result = parse("C*02:61:01")
    assert result.__class__ is Allele, f'Expected parse("C*02:61:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:61:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_61_02():
    result = parse("C*02:61:02")
    assert result.__class__ is Allele, f'Expected parse("C*02:61:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*02:61:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_62():
    result = parse("C*02:62")
    assert result.__class__ is Allele, f'Expected parse("C*02:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_63():
    result = parse("C*02:63")
    assert result.__class__ is Allele, f'Expected parse("C*02:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_64():
    result = parse("C*02:64")
    assert result.__class__ is Allele, f'Expected parse("C*02:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_65():
    result = parse("C*02:65")
    assert result.__class__ is Allele, f'Expected parse("C*02:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_66():
    result = parse("C*02:66")
    assert result.__class__ is Allele, f'Expected parse("C*02:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_67Q():
    result = parse("C*02:67Q")
    assert result.__class__ is Allele, f'Expected parse("C*02:67Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:67Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_68():
    result = parse("C*02:68")
    assert result.__class__ is Allele, f'Expected parse("C*02:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_69():
    result = parse("C*02:69")
    assert result.__class__ is Allele, f'Expected parse("C*02:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_70():
    result = parse("C*02:70")
    assert result.__class__ is Allele, f'Expected parse("C*02:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_71():
    result = parse("C*02:71")
    assert result.__class__ is Allele, f'Expected parse("C*02:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_72():
    result = parse("C*02:72")
    assert result.__class__ is Allele, f'Expected parse("C*02:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_73():
    result = parse("C*02:73")
    assert result.__class__ is Allele, f'Expected parse("C*02:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_74():
    result = parse("C*02:74")
    assert result.__class__ is Allele, f'Expected parse("C*02:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_75():
    result = parse("C*02:75")
    assert result.__class__ is Allele, f'Expected parse("C*02:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_76():
    result = parse("C*02:76")
    assert result.__class__ is Allele, f'Expected parse("C*02:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_77():
    result = parse("C*02:77")
    assert result.__class__ is Allele, f'Expected parse("C*02:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_78():
    result = parse("C*02:78")
    assert result.__class__ is Allele, f'Expected parse("C*02:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_79():
    result = parse("C*02:79")
    assert result.__class__ is Allele, f'Expected parse("C*02:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_80():
    result = parse("C*02:80")
    assert result.__class__ is Allele, f'Expected parse("C*02:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_81():
    result = parse("C*02:81")
    assert result.__class__ is Allele, f'Expected parse("C*02:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_82():
    result = parse("C*02:82")
    assert result.__class__ is Allele, f'Expected parse("C*02:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_83():
    result = parse("C*02:83")
    assert result.__class__ is Allele, f'Expected parse("C*02:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_84():
    result = parse("C*02:84")
    assert result.__class__ is Allele, f'Expected parse("C*02:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_85():
    result = parse("C*02:85")
    assert result.__class__ is Allele, f'Expected parse("C*02:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_86():
    result = parse("C*02:86")
    assert result.__class__ is Allele, f'Expected parse("C*02:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_87():
    result = parse("C*02:87")
    assert result.__class__ is Allele, f'Expected parse("C*02:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_88():
    result = parse("C*02:88")
    assert result.__class__ is Allele, f'Expected parse("C*02:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_89():
    result = parse("C*02:89")
    assert result.__class__ is Allele, f'Expected parse("C*02:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_90():
    result = parse("C*02:90")
    assert result.__class__ is Allele, f'Expected parse("C*02:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_91():
    result = parse("C*02:91")
    assert result.__class__ is Allele, f'Expected parse("C*02:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_92N():
    result = parse("C*02:92N")
    assert result.__class__ is Allele, f'Expected parse("C*02:92N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:92N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_93():
    result = parse("C*02:93")
    assert result.__class__ is Allele, f'Expected parse("C*02:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_94():
    result = parse("C*02:94")
    assert result.__class__ is Allele, f'Expected parse("C*02:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_95():
    result = parse("C*02:95")
    assert result.__class__ is Allele, f'Expected parse("C*02:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_96():
    result = parse("C*02:96")
    assert result.__class__ is Allele, f'Expected parse("C*02:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_97():
    result = parse("C*02:97")
    assert result.__class__ is Allele, f'Expected parse("C*02:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_98():
    result = parse("C*02:98")
    assert result.__class__ is Allele, f'Expected parse("C*02:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_02_99():
    result = parse("C*02:99")
    assert result.__class__ is Allele, f'Expected parse("C*02:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*02:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_01():
    result = parse("C*03:02:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_02_01():
    result = parse("C*03:02:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:02:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:02:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_02_02():
    result = parse("C*03:02:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:02:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:02:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_02_03():
    result = parse("C*03:02:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:02:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:02:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_02_04():
    result = parse("C*03:02:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:02:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:02:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_02_05():
    result = parse("C*03:02:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:02:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:02:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_02_06():
    result = parse("C*03:02:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:02:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:02:02:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_02_07():
    result = parse("C*03:02:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:02:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:02:02:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_02_08():
    result = parse("C*03:02:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:02:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:02:02:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_02_09():
    result = parse("C*03:02:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:02:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:02:02:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_03():
    result = parse("C*03:02:03")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_04():
    result = parse("C*03:02:04")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_05():
    result = parse("C*03:02:05")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_06():
    result = parse("C*03:02:06")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_07():
    result = parse("C*03:02:07")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_08():
    result = parse("C*03:02:08")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_09():
    result = parse("C*03:02:09")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_10():
    result = parse("C*03:02:10")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_11():
    result = parse("C*03:02:11")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_12():
    result = parse("C*03:02:12")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_13():
    result = parse("C*03:02:13")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_14():
    result = parse("C*03:02:14")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_15():
    result = parse("C*03:02:15")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_16():
    result = parse("C*03:02:16")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_17():
    result = parse("C*03:02:17")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_18():
    result = parse("C*03:02:18")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_19():
    result = parse("C*03:02:19")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_20():
    result = parse("C*03:02:20")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_21():
    result = parse("C*03:02:21")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_22():
    result = parse("C*03:02:22")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_23():
    result = parse("C*03:02:23")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_02_24():
    result = parse("C*03:02:24")
    assert result.__class__ is Allele, f'Expected parse("C*03:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_01():
    result = parse("C*03:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_02():
    result = parse("C*03:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_03():
    result = parse("C*03:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_04():
    result = parse("C*03:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_05():
    result = parse("C*03:03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_06():
    result = parse("C*03:03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_07():
    result = parse("C*03:03:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_08():
    result = parse("C*03:03:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_09():
    result = parse("C*03:03:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_10():
    result = parse("C*03:03:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_11():
    result = parse("C*03:03:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_12():
    result = parse("C*03:03:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_13():
    result = parse("C*03:03:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_14():
    result = parse("C*03:03:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_15():
    result = parse("C*03:03:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_16():
    result = parse("C*03:03:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_17():
    result = parse("C*03:03:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_18():
    result = parse("C*03:03:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_19():
    result = parse("C*03:03:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_20():
    result = parse("C*03:03:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_21():
    result = parse("C*03:03:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_22():
    result = parse("C*03:03:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_23():
    result = parse("C*03:03:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_24():
    result = parse("C*03:03:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_25():
    result = parse("C*03:03:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_26():
    result = parse("C*03:03:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_27():
    result = parse("C*03:03:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_28():
    result = parse("C*03:03:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_29():
    result = parse("C*03:03:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_30():
    result = parse("C*03:03:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_31():
    result = parse("C*03:03:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_32():
    result = parse("C*03:03:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_33():
    result = parse("C*03:03:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_34():
    result = parse("C*03:03:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_35():
    result = parse("C*03:03:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_36():
    result = parse("C*03:03:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_37():
    result = parse("C*03:03:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_38():
    result = parse("C*03:03:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_01_39():
    result = parse("C*03:03:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:03:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:03:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_02():
    result = parse("C*03:03:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_03():
    result = parse("C*03:03:03")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_04():
    result = parse("C*03:03:04")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_05():
    result = parse("C*03:03:05")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_06():
    result = parse("C*03:03:06")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_07():
    result = parse("C*03:03:07")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_08():
    result = parse("C*03:03:08")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_09():
    result = parse("C*03:03:09")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_10():
    result = parse("C*03:03:10")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_11():
    result = parse("C*03:03:11")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_12():
    result = parse("C*03:03:12")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_13():
    result = parse("C*03:03:13")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_14():
    result = parse("C*03:03:14")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_15():
    result = parse("C*03:03:15")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_16():
    result = parse("C*03:03:16")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_17():
    result = parse("C*03:03:17")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_18():
    result = parse("C*03:03:18")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_19():
    result = parse("C*03:03:19")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_20():
    result = parse("C*03:03:20")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_21():
    result = parse("C*03:03:21")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_22():
    result = parse("C*03:03:22")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_23():
    result = parse("C*03:03:23")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_24():
    result = parse("C*03:03:24")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_25():
    result = parse("C*03:03:25")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_26():
    result = parse("C*03:03:26")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_27():
    result = parse("C*03:03:27")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_28():
    result = parse("C*03:03:28")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_29():
    result = parse("C*03:03:29")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_30():
    result = parse("C*03:03:30")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_31():
    result = parse("C*03:03:31")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_32():
    result = parse("C*03:03:32")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_33():
    result = parse("C*03:03:33")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_34():
    result = parse("C*03:03:34")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_35():
    result = parse("C*03:03:35")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_36():
    result = parse("C*03:03:36")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_37():
    result = parse("C*03:03:37")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_38():
    result = parse("C*03:03:38")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_39():
    result = parse("C*03:03:39")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_40():
    result = parse("C*03:03:40")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_41():
    result = parse("C*03:03:41")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_42():
    result = parse("C*03:03:42")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_43():
    result = parse("C*03:03:43")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_44():
    result = parse("C*03:03:44")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_45():
    result = parse("C*03:03:45")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_46():
    result = parse("C*03:03:46")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_47():
    result = parse("C*03:03:47")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_48():
    result = parse("C*03:03:48")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_49():
    result = parse("C*03:03:49")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_50():
    result = parse("C*03:03:50")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_51():
    result = parse("C*03:03:51")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_52():
    result = parse("C*03:03:52")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_53():
    result = parse("C*03:03:53")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_54():
    result = parse("C*03:03:54")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_55():
    result = parse("C*03:03:55")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_56():
    result = parse("C*03:03:56")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_57():
    result = parse("C*03:03:57")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_03_58():
    result = parse("C*03:03:58")
    assert result.__class__ is Allele, f'Expected parse("C*03:03:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:03:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_01():
    result = parse("C*03:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_02():
    result = parse("C*03:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_03():
    result = parse("C*03:04:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_04():
    result = parse("C*03:04:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_05():
    result = parse("C*03:04:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_06():
    result = parse("C*03:04:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_07():
    result = parse("C*03:04:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_08():
    result = parse("C*03:04:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_09():
    result = parse("C*03:04:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_10():
    result = parse("C*03:04:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_11():
    result = parse("C*03:04:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_12():
    result = parse("C*03:04:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_13():
    result = parse("C*03:04:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_14():
    result = parse("C*03:04:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_15():
    result = parse("C*03:04:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_16():
    result = parse("C*03:04:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_17():
    result = parse("C*03:04:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_18():
    result = parse("C*03:04:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_19():
    result = parse("C*03:04:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_20():
    result = parse("C*03:04:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_21():
    result = parse("C*03:04:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_22():
    result = parse("C*03:04:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_23():
    result = parse("C*03:04:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_24():
    result = parse("C*03:04:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_25():
    result = parse("C*03:04:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_26():
    result = parse("C*03:04:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_27():
    result = parse("C*03:04:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_28():
    result = parse("C*03:04:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_29():
    result = parse("C*03:04:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_30():
    result = parse("C*03:04:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_31():
    result = parse("C*03:04:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_32():
    result = parse("C*03:04:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_33():
    result = parse("C*03:04:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_34():
    result = parse("C*03:04:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_35Q():
    result = parse("C*03:04:01:35Q")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:35Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:35Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_36():
    result = parse("C*03:04:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_37():
    result = parse("C*03:04:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_38():
    result = parse("C*03:04:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_39():
    result = parse("C*03:04:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_40():
    result = parse("C*03:04:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_41():
    result = parse("C*03:04:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_42():
    result = parse("C*03:04:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_43():
    result = parse("C*03:04:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_44():
    result = parse("C*03:04:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_45():
    result = parse("C*03:04:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:45") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_46():
    result = parse("C*03:04:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:46") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_47():
    result = parse("C*03:04:01:47")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:47") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_48():
    result = parse("C*03:04:01:48")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:48") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:48") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_49():
    result = parse("C*03:04:01:49")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:49") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:49") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_50():
    result = parse("C*03:04:01:50")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:50") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:50") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_01_51():
    result = parse("C*03:04:01:51")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:01:51") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:01:51") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_02_01():
    result = parse("C*03:04:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_02_02():
    result = parse("C*03:04:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_02_03():
    result = parse("C*03:04:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_02_04():
    result = parse("C*03:04:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_02_05():
    result = parse("C*03:04:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:04:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:04:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_03():
    result = parse("C*03:04:03")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_04():
    result = parse("C*03:04:04")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_05():
    result = parse("C*03:04:05")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_06():
    result = parse("C*03:04:06")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_07():
    result = parse("C*03:04:07")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_08():
    result = parse("C*03:04:08")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_09():
    result = parse("C*03:04:09")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_10():
    result = parse("C*03:04:10")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_11():
    result = parse("C*03:04:11")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_12():
    result = parse("C*03:04:12")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_13():
    result = parse("C*03:04:13")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_14():
    result = parse("C*03:04:14")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_15():
    result = parse("C*03:04:15")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_16():
    result = parse("C*03:04:16")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_17():
    result = parse("C*03:04:17")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_18():
    result = parse("C*03:04:18")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_19():
    result = parse("C*03:04:19")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_20():
    result = parse("C*03:04:20")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_21():
    result = parse("C*03:04:21")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_22():
    result = parse("C*03:04:22")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_23():
    result = parse("C*03:04:23")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_24():
    result = parse("C*03:04:24")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_25():
    result = parse("C*03:04:25")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_26():
    result = parse("C*03:04:26")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_27():
    result = parse("C*03:04:27")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_28():
    result = parse("C*03:04:28")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_29():
    result = parse("C*03:04:29")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_30():
    result = parse("C*03:04:30")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_31():
    result = parse("C*03:04:31")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_32():
    result = parse("C*03:04:32")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_33():
    result = parse("C*03:04:33")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_34():
    result = parse("C*03:04:34")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_35():
    result = parse("C*03:04:35")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_36():
    result = parse("C*03:04:36")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_37():
    result = parse("C*03:04:37")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_38():
    result = parse("C*03:04:38")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_39():
    result = parse("C*03:04:39")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_40():
    result = parse("C*03:04:40")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_41():
    result = parse("C*03:04:41")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_42():
    result = parse("C*03:04:42")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_43():
    result = parse("C*03:04:43")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_44():
    result = parse("C*03:04:44")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_45():
    result = parse("C*03:04:45")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_46():
    result = parse("C*03:04:46")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_47():
    result = parse("C*03:04:47")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_48():
    result = parse("C*03:04:48")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_49():
    result = parse("C*03:04:49")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_50():
    result = parse("C*03:04:50")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_51():
    result = parse("C*03:04:51")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_52():
    result = parse("C*03:04:52")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_53():
    result = parse("C*03:04:53")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_54():
    result = parse("C*03:04:54")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_55():
    result = parse("C*03:04:55")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_56():
    result = parse("C*03:04:56")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_57():
    result = parse("C*03:04:57")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_58():
    result = parse("C*03:04:58")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_59():
    result = parse("C*03:04:59")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_60():
    result = parse("C*03:04:60")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_61():
    result = parse("C*03:04:61")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_62():
    result = parse("C*03:04:62")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_63():
    result = parse("C*03:04:63")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_64():
    result = parse("C*03:04:64")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_65():
    result = parse("C*03:04:65")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_66():
    result = parse("C*03:04:66")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:66") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:66") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_67():
    result = parse("C*03:04:67")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:67") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:67") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_68():
    result = parse("C*03:04:68")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:68") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:68") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_69():
    result = parse("C*03:04:69")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:69") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:69") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_70():
    result = parse("C*03:04:70")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:70") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:70") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_71():
    result = parse("C*03:04:71")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:71") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:71") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_72():
    result = parse("C*03:04:72")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:72") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:72") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_73():
    result = parse("C*03:04:73")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:73") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:73") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_74():
    result = parse("C*03:04:74")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:74") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:74") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_75():
    result = parse("C*03:04:75")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:75") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:75") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_76():
    result = parse("C*03:04:76")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:76") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:76") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_77():
    result = parse("C*03:04:77")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:77") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:77") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_78():
    result = parse("C*03:04:78")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:78") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:78") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_79():
    result = parse("C*03:04:79")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:79") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:79") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_80():
    result = parse("C*03:04:80")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:80") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:80") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_81():
    result = parse("C*03:04:81")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:81") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:81") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_04_82():
    result = parse("C*03:04:82")
    assert result.__class__ is Allele, f'Expected parse("C*03:04:82") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:04:82") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_05():
    result = parse("C*03:05")
    assert result.__class__ is Allele, f'Expected parse("C*03:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_06_01():
    result = parse("C*03:06:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:06:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_06_02():
    result = parse("C*03:06:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:06:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_07_01_01():
    result = parse("C*03:07:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:07:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:07:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_07_01_02():
    result = parse("C*03:07:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:07:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:07:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_07_01_03():
    result = parse("C*03:07:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:07:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:07:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_07_01_04():
    result = parse("C*03:07:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:07:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:07:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_07_02():
    result = parse("C*03:07:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:07:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_08():
    result = parse("C*03:08")
    assert result.__class__ is Allele, f'Expected parse("C*03:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_09():
    result = parse("C*03:09")
    assert result.__class__ is Allele, f'Expected parse("C*03:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_10():
    result = parse("C*03:10")
    assert result.__class__ is Allele, f'Expected parse("C*03:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_100():
    result = parse("C*03:100")
    assert result.__class__ is Allele, f'Expected parse("C*03:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_101():
    result = parse("C*03:101")
    assert result.__class__ is Allele, f'Expected parse("C*03:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_102():
    result = parse("C*03:102")
    assert result.__class__ is Allele, f'Expected parse("C*03:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_103():
    result = parse("C*03:103")
    assert result.__class__ is Allele, f'Expected parse("C*03:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_104():
    result = parse("C*03:104")
    assert result.__class__ is Allele, f'Expected parse("C*03:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_105():
    result = parse("C*03:105")
    assert result.__class__ is Allele, f'Expected parse("C*03:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_106():
    result = parse("C*03:106")
    assert result.__class__ is Allele, f'Expected parse("C*03:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_107():
    result = parse("C*03:107")
    assert result.__class__ is Allele, f'Expected parse("C*03:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_108():
    result = parse("C*03:108")
    assert result.__class__ is Allele, f'Expected parse("C*03:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_109():
    result = parse("C*03:109")
    assert result.__class__ is Allele, f'Expected parse("C*03:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_110():
    result = parse("C*03:110")
    assert result.__class__ is Allele, f'Expected parse("C*03:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_111():
    result = parse("C*03:111")
    assert result.__class__ is Allele, f'Expected parse("C*03:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_112():
    result = parse("C*03:112")
    assert result.__class__ is Allele, f'Expected parse("C*03:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_113_01():
    result = parse("C*03:113:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:113:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:113:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_113_02():
    result = parse("C*03:113:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:113:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:113:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_114():
    result = parse("C*03:114")
    assert result.__class__ is Allele, f'Expected parse("C*03:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_115_01():
    result = parse("C*03:115:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:115:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:115:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_115_02():
    result = parse("C*03:115:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:115:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:115:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_116_01():
    result = parse("C*03:116:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:116:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:116:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_116_02():
    result = parse("C*03:116:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:116:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:116:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_117():
    result = parse("C*03:117")
    assert result.__class__ is Allele, f'Expected parse("C*03:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_118():
    result = parse("C*03:118")
    assert result.__class__ is Allele, f'Expected parse("C*03:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_119_01():
    result = parse("C*03:119:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:119:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:119:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_119_02():
    result = parse("C*03:119:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:119:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:119:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_11_01():
    result = parse("C*03:11:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:11:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:11:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_11_02():
    result = parse("C*03:11:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:11:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:11:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_120():
    result = parse("C*03:120")
    assert result.__class__ is Allele, f'Expected parse("C*03:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_121N():
    result = parse("C*03:121N")
    assert result.__class__ is Allele, f'Expected parse("C*03:121N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:121N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_122():
    result = parse("C*03:122")
    assert result.__class__ is Allele, f'Expected parse("C*03:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_123():
    result = parse("C*03:123")
    assert result.__class__ is Allele, f'Expected parse("C*03:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_124():
    result = parse("C*03:124")
    assert result.__class__ is Allele, f'Expected parse("C*03:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_125():
    result = parse("C*03:125")
    assert result.__class__ is Allele, f'Expected parse("C*03:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_126():
    result = parse("C*03:126")
    assert result.__class__ is Allele, f'Expected parse("C*03:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_127():
    result = parse("C*03:127")
    assert result.__class__ is Allele, f'Expected parse("C*03:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_128():
    result = parse("C*03:128")
    assert result.__class__ is Allele, f'Expected parse("C*03:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_129():
    result = parse("C*03:129")
    assert result.__class__ is Allele, f'Expected parse("C*03:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_130():
    result = parse("C*03:130")
    assert result.__class__ is Allele, f'Expected parse("C*03:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_131():
    result = parse("C*03:131")
    assert result.__class__ is Allele, f'Expected parse("C*03:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_132():
    result = parse("C*03:132")
    assert result.__class__ is Allele, f'Expected parse("C*03:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_133():
    result = parse("C*03:133")
    assert result.__class__ is Allele, f'Expected parse("C*03:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_134():
    result = parse("C*03:134")
    assert result.__class__ is Allele, f'Expected parse("C*03:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_135():
    result = parse("C*03:135")
    assert result.__class__ is Allele, f'Expected parse("C*03:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_136():
    result = parse("C*03:136")
    assert result.__class__ is Allele, f'Expected parse("C*03:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_137():
    result = parse("C*03:137")
    assert result.__class__ is Allele, f'Expected parse("C*03:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_138():
    result = parse("C*03:138")
    assert result.__class__ is Allele, f'Expected parse("C*03:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_139():
    result = parse("C*03:139")
    assert result.__class__ is Allele, f'Expected parse("C*03:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_13_01_01():
    result = parse("C*03:13:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:13:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:13:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_13_01_02():
    result = parse("C*03:13:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:13:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:13:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_13_02():
    result = parse("C*03:13:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:13:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:13:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_14():
    result = parse("C*03:14")
    assert result.__class__ is Allele, f'Expected parse("C*03:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_140_01_01():
    result = parse("C*03:140:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:140:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:140:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_140_01_02():
    result = parse("C*03:140:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:140:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:140:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_141():
    result = parse("C*03:141")
    assert result.__class__ is Allele, f'Expected parse("C*03:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_142():
    result = parse("C*03:142")
    assert result.__class__ is Allele, f'Expected parse("C*03:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_143():
    result = parse("C*03:143")
    assert result.__class__ is Allele, f'Expected parse("C*03:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_144():
    result = parse("C*03:144")
    assert result.__class__ is Allele, f'Expected parse("C*03:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_145():
    result = parse("C*03:145")
    assert result.__class__ is Allele, f'Expected parse("C*03:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_146():
    result = parse("C*03:146")
    assert result.__class__ is Allele, f'Expected parse("C*03:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_147():
    result = parse("C*03:147")
    assert result.__class__ is Allele, f'Expected parse("C*03:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_148():
    result = parse("C*03:148")
    assert result.__class__ is Allele, f'Expected parse("C*03:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_149():
    result = parse("C*03:149")
    assert result.__class__ is Allele, f'Expected parse("C*03:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_15():
    result = parse("C*03:15")
    assert result.__class__ is Allele, f'Expected parse("C*03:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_150():
    result = parse("C*03:150")
    assert result.__class__ is Allele, f'Expected parse("C*03:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_151():
    result = parse("C*03:151")
    assert result.__class__ is Allele, f'Expected parse("C*03:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_152():
    result = parse("C*03:152")
    assert result.__class__ is Allele, f'Expected parse("C*03:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_153():
    result = parse("C*03:153")
    assert result.__class__ is Allele, f'Expected parse("C*03:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_154():
    result = parse("C*03:154")
    assert result.__class__ is Allele, f'Expected parse("C*03:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_155():
    result = parse("C*03:155")
    assert result.__class__ is Allele, f'Expected parse("C*03:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_156():
    result = parse("C*03:156")
    assert result.__class__ is Allele, f'Expected parse("C*03:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_157():
    result = parse("C*03:157")
    assert result.__class__ is Allele, f'Expected parse("C*03:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_158():
    result = parse("C*03:158")
    assert result.__class__ is Allele, f'Expected parse("C*03:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_159():
    result = parse("C*03:159")
    assert result.__class__ is Allele, f'Expected parse("C*03:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_16():
    result = parse("C*03:16")
    assert result.__class__ is Allele, f'Expected parse("C*03:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_160():
    result = parse("C*03:160")
    assert result.__class__ is Allele, f'Expected parse("C*03:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_161():
    result = parse("C*03:161")
    assert result.__class__ is Allele, f'Expected parse("C*03:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_162():
    result = parse("C*03:162")
    assert result.__class__ is Allele, f'Expected parse("C*03:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_163():
    result = parse("C*03:163")
    assert result.__class__ is Allele, f'Expected parse("C*03:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_164():
    result = parse("C*03:164")
    assert result.__class__ is Allele, f'Expected parse("C*03:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_165_01():
    result = parse("C*03:165:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:165:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:165:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_165_02():
    result = parse("C*03:165:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:165:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:165:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_166():
    result = parse("C*03:166")
    assert result.__class__ is Allele, f'Expected parse("C*03:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_167():
    result = parse("C*03:167")
    assert result.__class__ is Allele, f'Expected parse("C*03:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_168():
    result = parse("C*03:168")
    assert result.__class__ is Allele, f'Expected parse("C*03:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_169Q():
    result = parse("C*03:169Q")
    assert result.__class__ is Allele, f'Expected parse("C*03:169Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:169Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_170():
    result = parse("C*03:170")
    assert result.__class__ is Allele, f'Expected parse("C*03:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_171():
    result = parse("C*03:171")
    assert result.__class__ is Allele, f'Expected parse("C*03:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_172():
    result = parse("C*03:172")
    assert result.__class__ is Allele, f'Expected parse("C*03:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_173():
    result = parse("C*03:173")
    assert result.__class__ is Allele, f'Expected parse("C*03:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_174():
    result = parse("C*03:174")
    assert result.__class__ is Allele, f'Expected parse("C*03:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_175():
    result = parse("C*03:175")
    assert result.__class__ is Allele, f'Expected parse("C*03:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_176():
    result = parse("C*03:176")
    assert result.__class__ is Allele, f'Expected parse("C*03:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_177():
    result = parse("C*03:177")
    assert result.__class__ is Allele, f'Expected parse("C*03:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_178():
    result = parse("C*03:178")
    assert result.__class__ is Allele, f'Expected parse("C*03:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_179():
    result = parse("C*03:179")
    assert result.__class__ is Allele, f'Expected parse("C*03:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_17_01():
    result = parse("C*03:17:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:17:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:17:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_17_02():
    result = parse("C*03:17:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:17:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:17:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_180():
    result = parse("C*03:180")
    assert result.__class__ is Allele, f'Expected parse("C*03:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_181():
    result = parse("C*03:181")
    assert result.__class__ is Allele, f'Expected parse("C*03:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_182():
    result = parse("C*03:182")
    assert result.__class__ is Allele, f'Expected parse("C*03:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_183():
    result = parse("C*03:183")
    assert result.__class__ is Allele, f'Expected parse("C*03:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_184_01():
    result = parse("C*03:184:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:184:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:184:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_184_02():
    result = parse("C*03:184:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:184:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:184:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_185():
    result = parse("C*03:185")
    assert result.__class__ is Allele, f'Expected parse("C*03:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_186_01():
    result = parse("C*03:186:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:186:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:186:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_186_02():
    result = parse("C*03:186:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:186:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:186:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_187():
    result = parse("C*03:187")
    assert result.__class__ is Allele, f'Expected parse("C*03:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_188():
    result = parse("C*03:188")
    assert result.__class__ is Allele, f'Expected parse("C*03:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_189N():
    result = parse("C*03:189N")
    assert result.__class__ is Allele, f'Expected parse("C*03:189N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:189N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_18_01():
    result = parse("C*03:18:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:18:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:18:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_18_02():
    result = parse("C*03:18:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:18:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:18:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_18_03():
    result = parse("C*03:18:03")
    assert result.__class__ is Allele, f'Expected parse("C*03:18:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:18:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_19():
    result = parse("C*03:19")
    assert result.__class__ is Allele, f'Expected parse("C*03:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_190():
    result = parse("C*03:190")
    assert result.__class__ is Allele, f'Expected parse("C*03:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_191():
    result = parse("C*03:191")
    assert result.__class__ is Allele, f'Expected parse("C*03:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_192():
    result = parse("C*03:192")
    assert result.__class__ is Allele, f'Expected parse("C*03:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_193():
    result = parse("C*03:193")
    assert result.__class__ is Allele, f'Expected parse("C*03:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_194():
    result = parse("C*03:194")
    assert result.__class__ is Allele, f'Expected parse("C*03:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_195():
    result = parse("C*03:195")
    assert result.__class__ is Allele, f'Expected parse("C*03:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_196():
    result = parse("C*03:196")
    assert result.__class__ is Allele, f'Expected parse("C*03:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_197():
    result = parse("C*03:197")
    assert result.__class__ is Allele, f'Expected parse("C*03:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_198():
    result = parse("C*03:198")
    assert result.__class__ is Allele, f'Expected parse("C*03:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_199():
    result = parse("C*03:199")
    assert result.__class__ is Allele, f'Expected parse("C*03:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_200():
    result = parse("C*03:200")
    assert result.__class__ is Allele, f'Expected parse("C*03:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_201N():
    result = parse("C*03:201N")
    assert result.__class__ is Allele, f'Expected parse("C*03:201N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:201N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_202():
    result = parse("C*03:202")
    assert result.__class__ is Allele, f'Expected parse("C*03:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_203():
    result = parse("C*03:203")
    assert result.__class__ is Allele, f'Expected parse("C*03:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_204():
    result = parse("C*03:204")
    assert result.__class__ is Allele, f'Expected parse("C*03:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_205():
    result = parse("C*03:205")
    assert result.__class__ is Allele, f'Expected parse("C*03:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_206():
    result = parse("C*03:206")
    assert result.__class__ is Allele, f'Expected parse("C*03:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_207():
    result = parse("C*03:207")
    assert result.__class__ is Allele, f'Expected parse("C*03:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_208N():
    result = parse("C*03:208N")
    assert result.__class__ is Allele, f'Expected parse("C*03:208N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:208N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_209():
    result = parse("C*03:209")
    assert result.__class__ is Allele, f'Expected parse("C*03:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_20N():
    result = parse("C*03:20N")
    assert result.__class__ is Allele, f'Expected parse("C*03:20N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:20N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_21():
    result = parse("C*03:21")
    assert result.__class__ is Allele, f'Expected parse("C*03:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_210():
    result = parse("C*03:210")
    assert result.__class__ is Allele, f'Expected parse("C*03:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_211_01():
    result = parse("C*03:211:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:211:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:211:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_211_02():
    result = parse("C*03:211:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:211:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:211:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_212():
    result = parse("C*03:212")
    assert result.__class__ is Allele, f'Expected parse("C*03:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_213():
    result = parse("C*03:213")
    assert result.__class__ is Allele, f'Expected parse("C*03:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_214():
    result = parse("C*03:214")
    assert result.__class__ is Allele, f'Expected parse("C*03:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_215():
    result = parse("C*03:215")
    assert result.__class__ is Allele, f'Expected parse("C*03:215") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_216():
    result = parse("C*03:216")
    assert result.__class__ is Allele, f'Expected parse("C*03:216") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_217():
    result = parse("C*03:217")
    assert result.__class__ is Allele, f'Expected parse("C*03:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_218():
    result = parse("C*03:218")
    assert result.__class__ is Allele, f'Expected parse("C*03:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_219():
    result = parse("C*03:219")
    assert result.__class__ is Allele, f'Expected parse("C*03:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_220():
    result = parse("C*03:220")
    assert result.__class__ is Allele, f'Expected parse("C*03:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_221():
    result = parse("C*03:221")
    assert result.__class__ is Allele, f'Expected parse("C*03:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_222():
    result = parse("C*03:222")
    assert result.__class__ is Allele, f'Expected parse("C*03:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_223():
    result = parse("C*03:223")
    assert result.__class__ is Allele, f'Expected parse("C*03:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_224N():
    result = parse("C*03:224N")
    assert result.__class__ is Allele, f'Expected parse("C*03:224N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:224N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_225():
    result = parse("C*03:225")
    assert result.__class__ is Allele, f'Expected parse("C*03:225") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_226():
    result = parse("C*03:226")
    assert result.__class__ is Allele, f'Expected parse("C*03:226") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_227():
    result = parse("C*03:227")
    assert result.__class__ is Allele, f'Expected parse("C*03:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_228():
    result = parse("C*03:228")
    assert result.__class__ is Allele, f'Expected parse("C*03:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_229N():
    result = parse("C*03:229N")
    assert result.__class__ is Allele, f'Expected parse("C*03:229N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:229N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_22Q():
    result = parse("C*03:22Q")
    assert result.__class__ is Allele, f'Expected parse("C*03:22Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:22Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_230():
    result = parse("C*03:230")
    assert result.__class__ is Allele, f'Expected parse("C*03:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_231():
    result = parse("C*03:231")
    assert result.__class__ is Allele, f'Expected parse("C*03:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_232():
    result = parse("C*03:232")
    assert result.__class__ is Allele, f'Expected parse("C*03:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_233():
    result = parse("C*03:233")
    assert result.__class__ is Allele, f'Expected parse("C*03:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_234():
    result = parse("C*03:234")
    assert result.__class__ is Allele, f'Expected parse("C*03:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_235():
    result = parse("C*03:235")
    assert result.__class__ is Allele, f'Expected parse("C*03:235") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_236():
    result = parse("C*03:236")
    assert result.__class__ is Allele, f'Expected parse("C*03:236") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_237():
    result = parse("C*03:237")
    assert result.__class__ is Allele, f'Expected parse("C*03:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_238():
    result = parse("C*03:238")
    assert result.__class__ is Allele, f'Expected parse("C*03:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_239():
    result = parse("C*03:239")
    assert result.__class__ is Allele, f'Expected parse("C*03:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_23N():
    result = parse("C*03:23N")
    assert result.__class__ is Allele, f'Expected parse("C*03:23N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:23N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_24():
    result = parse("C*03:24")
    assert result.__class__ is Allele, f'Expected parse("C*03:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_240():
    result = parse("C*03:240")
    assert result.__class__ is Allele, f'Expected parse("C*03:240") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_241():
    result = parse("C*03:241")
    assert result.__class__ is Allele, f'Expected parse("C*03:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_242():
    result = parse("C*03:242")
    assert result.__class__ is Allele, f'Expected parse("C*03:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_243():
    result = parse("C*03:243")
    assert result.__class__ is Allele, f'Expected parse("C*03:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_244Q():
    result = parse("C*03:244Q")
    assert result.__class__ is Allele, f'Expected parse("C*03:244Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:244Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_245():
    result = parse("C*03:245")
    assert result.__class__ is Allele, f'Expected parse("C*03:245") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_246():
    result = parse("C*03:246")
    assert result.__class__ is Allele, f'Expected parse("C*03:246") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_247():
    result = parse("C*03:247")
    assert result.__class__ is Allele, f'Expected parse("C*03:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_248():
    result = parse("C*03:248")
    assert result.__class__ is Allele, f'Expected parse("C*03:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_249():
    result = parse("C*03:249")
    assert result.__class__ is Allele, f'Expected parse("C*03:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_25():
    result = parse("C*03:25")
    assert result.__class__ is Allele, f'Expected parse("C*03:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_250():
    result = parse("C*03:250")
    assert result.__class__ is Allele, f'Expected parse("C*03:250") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_251():
    result = parse("C*03:251")
    assert result.__class__ is Allele, f'Expected parse("C*03:251") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_252():
    result = parse("C*03:252")
    assert result.__class__ is Allele, f'Expected parse("C*03:252") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_253():
    result = parse("C*03:253")
    assert result.__class__ is Allele, f'Expected parse("C*03:253") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_254():
    result = parse("C*03:254")
    assert result.__class__ is Allele, f'Expected parse("C*03:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_255():
    result = parse("C*03:255")
    assert result.__class__ is Allele, f'Expected parse("C*03:255") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_256():
    result = parse("C*03:256")
    assert result.__class__ is Allele, f'Expected parse("C*03:256") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_257():
    result = parse("C*03:257")
    assert result.__class__ is Allele, f'Expected parse("C*03:257") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_258():
    result = parse("C*03:258")
    assert result.__class__ is Allele, f'Expected parse("C*03:258") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_259():
    result = parse("C*03:259")
    assert result.__class__ is Allele, f'Expected parse("C*03:259") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_260():
    result = parse("C*03:260")
    assert result.__class__ is Allele, f'Expected parse("C*03:260") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_261():
    result = parse("C*03:261")
    assert result.__class__ is Allele, f'Expected parse("C*03:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_262():
    result = parse("C*03:262")
    assert result.__class__ is Allele, f'Expected parse("C*03:262") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_263_01():
    result = parse("C*03:263:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:263:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:263:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_263_02():
    result = parse("C*03:263:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:263:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:263:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_263_03():
    result = parse("C*03:263:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:263:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:263:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_264():
    result = parse("C*03:264")
    assert result.__class__ is Allele, f'Expected parse("C*03:264") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_265N():
    result = parse("C*03:265N")
    assert result.__class__ is Allele, f'Expected parse("C*03:265N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:265N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_266():
    result = parse("C*03:266")
    assert result.__class__ is Allele, f'Expected parse("C*03:266") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_267():
    result = parse("C*03:267")
    assert result.__class__ is Allele, f'Expected parse("C*03:267") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_268():
    result = parse("C*03:268")
    assert result.__class__ is Allele, f'Expected parse("C*03:268") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_269():
    result = parse("C*03:269")
    assert result.__class__ is Allele, f'Expected parse("C*03:269") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_26_01():
    result = parse("C*03:26:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:26:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:26:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_26_02():
    result = parse("C*03:26:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:26:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:26:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_27():
    result = parse("C*03:27")
    assert result.__class__ is Allele, f'Expected parse("C*03:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_270():
    result = parse("C*03:270")
    assert result.__class__ is Allele, f'Expected parse("C*03:270") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_271():
    result = parse("C*03:271")
    assert result.__class__ is Allele, f'Expected parse("C*03:271") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_272():
    result = parse("C*03:272")
    assert result.__class__ is Allele, f'Expected parse("C*03:272") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_273():
    result = parse("C*03:273")
    assert result.__class__ is Allele, f'Expected parse("C*03:273") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_274():
    result = parse("C*03:274")
    assert result.__class__ is Allele, f'Expected parse("C*03:274") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_275():
    result = parse("C*03:275")
    assert result.__class__ is Allele, f'Expected parse("C*03:275") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_276():
    result = parse("C*03:276")
    assert result.__class__ is Allele, f'Expected parse("C*03:276") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_277N():
    result = parse("C*03:277N")
    assert result.__class__ is Allele, f'Expected parse("C*03:277N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:277N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_278():
    result = parse("C*03:278")
    assert result.__class__ is Allele, f'Expected parse("C*03:278") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_279():
    result = parse("C*03:279")
    assert result.__class__ is Allele, f'Expected parse("C*03:279") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_28():
    result = parse("C*03:28")
    assert result.__class__ is Allele, f'Expected parse("C*03:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_280():
    result = parse("C*03:280")
    assert result.__class__ is Allele, f'Expected parse("C*03:280") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_281():
    result = parse("C*03:281")
    assert result.__class__ is Allele, f'Expected parse("C*03:281") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_282():
    result = parse("C*03:282")
    assert result.__class__ is Allele, f'Expected parse("C*03:282") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_283():
    result = parse("C*03:283")
    assert result.__class__ is Allele, f'Expected parse("C*03:283") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_284():
    result = parse("C*03:284")
    assert result.__class__ is Allele, f'Expected parse("C*03:284") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_285():
    result = parse("C*03:285")
    assert result.__class__ is Allele, f'Expected parse("C*03:285") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_286():
    result = parse("C*03:286")
    assert result.__class__ is Allele, f'Expected parse("C*03:286") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_287_01():
    result = parse("C*03:287:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:287:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:287:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_287_02():
    result = parse("C*03:287:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:287:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:287:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_288():
    result = parse("C*03:288")
    assert result.__class__ is Allele, f'Expected parse("C*03:288") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_289():
    result = parse("C*03:289")
    assert result.__class__ is Allele, f'Expected parse("C*03:289") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_29():
    result = parse("C*03:29")
    assert result.__class__ is Allele, f'Expected parse("C*03:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_290():
    result = parse("C*03:290")
    assert result.__class__ is Allele, f'Expected parse("C*03:290") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_291():
    result = parse("C*03:291")
    assert result.__class__ is Allele, f'Expected parse("C*03:291") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_292():
    result = parse("C*03:292")
    assert result.__class__ is Allele, f'Expected parse("C*03:292") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_293():
    result = parse("C*03:293")
    assert result.__class__ is Allele, f'Expected parse("C*03:293") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_294():
    result = parse("C*03:294")
    assert result.__class__ is Allele, f'Expected parse("C*03:294") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_295():
    result = parse("C*03:295")
    assert result.__class__ is Allele, f'Expected parse("C*03:295") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_296_01():
    result = parse("C*03:296:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:296:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:296:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_296_02():
    result = parse("C*03:296:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:296:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:296:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_297():
    result = parse("C*03:297")
    assert result.__class__ is Allele, f'Expected parse("C*03:297") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_298():
    result = parse("C*03:298")
    assert result.__class__ is Allele, f'Expected parse("C*03:298") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_299():
    result = parse("C*03:299")
    assert result.__class__ is Allele, f'Expected parse("C*03:299") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_30():
    result = parse("C*03:30")
    assert result.__class__ is Allele, f'Expected parse("C*03:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_300():
    result = parse("C*03:300")
    assert result.__class__ is Allele, f'Expected parse("C*03:300") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_301():
    result = parse("C*03:301")
    assert result.__class__ is Allele, f'Expected parse("C*03:301") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_302():
    result = parse("C*03:302")
    assert result.__class__ is Allele, f'Expected parse("C*03:302") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_303():
    result = parse("C*03:303")
    assert result.__class__ is Allele, f'Expected parse("C*03:303") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:303") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_304():
    result = parse("C*03:304")
    assert result.__class__ is Allele, f'Expected parse("C*03:304") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:304") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_305():
    result = parse("C*03:305")
    assert result.__class__ is Allele, f'Expected parse("C*03:305") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_306():
    result = parse("C*03:306")
    assert result.__class__ is Allele, f'Expected parse("C*03:306") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:306") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_307():
    result = parse("C*03:307")
    assert result.__class__ is Allele, f'Expected parse("C*03:307") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_308():
    result = parse("C*03:308")
    assert result.__class__ is Allele, f'Expected parse("C*03:308") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:308") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_309():
    result = parse("C*03:309")
    assert result.__class__ is Allele, f'Expected parse("C*03:309") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:309") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_31():
    result = parse("C*03:31")
    assert result.__class__ is Allele, f'Expected parse("C*03:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_310():
    result = parse("C*03:310")
    assert result.__class__ is Allele, f'Expected parse("C*03:310") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:310") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_311():
    result = parse("C*03:311")
    assert result.__class__ is Allele, f'Expected parse("C*03:311") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:311") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_312():
    result = parse("C*03:312")
    assert result.__class__ is Allele, f'Expected parse("C*03:312") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:312") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_313():
    result = parse("C*03:313")
    assert result.__class__ is Allele, f'Expected parse("C*03:313") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:313") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_314():
    result = parse("C*03:314")
    assert result.__class__ is Allele, f'Expected parse("C*03:314") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:314") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_315():
    result = parse("C*03:315")
    assert result.__class__ is Allele, f'Expected parse("C*03:315") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:315") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_316N():
    result = parse("C*03:316N")
    assert result.__class__ is Allele, f'Expected parse("C*03:316N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:316N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_317():
    result = parse("C*03:317")
    assert result.__class__ is Allele, f'Expected parse("C*03:317") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:317") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_318N():
    result = parse("C*03:318N")
    assert result.__class__ is Allele, f'Expected parse("C*03:318N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:318N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_319():
    result = parse("C*03:319")
    assert result.__class__ is Allele, f'Expected parse("C*03:319") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_32():
    result = parse("C*03:32")
    assert result.__class__ is Allele, f'Expected parse("C*03:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_320():
    result = parse("C*03:320")
    assert result.__class__ is Allele, f'Expected parse("C*03:320") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:320") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_321():
    result = parse("C*03:321")
    assert result.__class__ is Allele, f'Expected parse("C*03:321") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:321") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_322():
    result = parse("C*03:322")
    assert result.__class__ is Allele, f'Expected parse("C*03:322") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:322") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_323N():
    result = parse("C*03:323N")
    assert result.__class__ is Allele, f'Expected parse("C*03:323N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:323N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_324():
    result = parse("C*03:324")
    assert result.__class__ is Allele, f'Expected parse("C*03:324") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:324") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_325():
    result = parse("C*03:325")
    assert result.__class__ is Allele, f'Expected parse("C*03:325") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:325") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_326():
    result = parse("C*03:326")
    assert result.__class__ is Allele, f'Expected parse("C*03:326") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:326") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_327():
    result = parse("C*03:327")
    assert result.__class__ is Allele, f'Expected parse("C*03:327") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:327") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_328():
    result = parse("C*03:328")
    assert result.__class__ is Allele, f'Expected parse("C*03:328") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:328") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_329():
    result = parse("C*03:329")
    assert result.__class__ is Allele, f'Expected parse("C*03:329") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:329") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_33():
    result = parse("C*03:33")
    assert result.__class__ is Allele, f'Expected parse("C*03:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_330():
    result = parse("C*03:330")
    assert result.__class__ is Allele, f'Expected parse("C*03:330") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:330") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_331():
    result = parse("C*03:331")
    assert result.__class__ is Allele, f'Expected parse("C*03:331") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:331") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_332():
    result = parse("C*03:332")
    assert result.__class__ is Allele, f'Expected parse("C*03:332") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:332") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_333():
    result = parse("C*03:333")
    assert result.__class__ is Allele, f'Expected parse("C*03:333") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:333") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_334():
    result = parse("C*03:334")
    assert result.__class__ is Allele, f'Expected parse("C*03:334") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:334") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_335():
    result = parse("C*03:335")
    assert result.__class__ is Allele, f'Expected parse("C*03:335") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:335") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_336():
    result = parse("C*03:336")
    assert result.__class__ is Allele, f'Expected parse("C*03:336") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:336") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_337():
    result = parse("C*03:337")
    assert result.__class__ is Allele, f'Expected parse("C*03:337") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:337") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_338():
    result = parse("C*03:338")
    assert result.__class__ is Allele, f'Expected parse("C*03:338") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:338") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_339():
    result = parse("C*03:339")
    assert result.__class__ is Allele, f'Expected parse("C*03:339") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:339") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_34():
    result = parse("C*03:34")
    assert result.__class__ is Allele, f'Expected parse("C*03:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_340():
    result = parse("C*03:340")
    assert result.__class__ is Allele, f'Expected parse("C*03:340") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:340") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_341():
    result = parse("C*03:341")
    assert result.__class__ is Allele, f'Expected parse("C*03:341") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:341") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_342():
    result = parse("C*03:342")
    assert result.__class__ is Allele, f'Expected parse("C*03:342") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:342") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_343():
    result = parse("C*03:343")
    assert result.__class__ is Allele, f'Expected parse("C*03:343") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:343") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_344_01_01():
    result = parse("C*03:344:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:344:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:344:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_344_01_02():
    result = parse("C*03:344:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:344:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:344:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_345():
    result = parse("C*03:345")
    assert result.__class__ is Allele, f'Expected parse("C*03:345") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:345") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_346():
    result = parse("C*03:346")
    assert result.__class__ is Allele, f'Expected parse("C*03:346") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:346") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_347():
    result = parse("C*03:347")
    assert result.__class__ is Allele, f'Expected parse("C*03:347") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:347") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_348():
    result = parse("C*03:348")
    assert result.__class__ is Allele, f'Expected parse("C*03:348") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:348") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_349():
    result = parse("C*03:349")
    assert result.__class__ is Allele, f'Expected parse("C*03:349") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:349") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_350():
    result = parse("C*03:350")
    assert result.__class__ is Allele, f'Expected parse("C*03:350") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:350") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_351():
    result = parse("C*03:351")
    assert result.__class__ is Allele, f'Expected parse("C*03:351") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:351") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_352():
    result = parse("C*03:352")
    assert result.__class__ is Allele, f'Expected parse("C*03:352") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:352") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_353():
    result = parse("C*03:353")
    assert result.__class__ is Allele, f'Expected parse("C*03:353") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:353") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_354():
    result = parse("C*03:354")
    assert result.__class__ is Allele, f'Expected parse("C*03:354") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:354") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_355():
    result = parse("C*03:355")
    assert result.__class__ is Allele, f'Expected parse("C*03:355") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:355") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_356():
    result = parse("C*03:356")
    assert result.__class__ is Allele, f'Expected parse("C*03:356") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:356") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_357():
    result = parse("C*03:357")
    assert result.__class__ is Allele, f'Expected parse("C*03:357") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:357") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_358():
    result = parse("C*03:358")
    assert result.__class__ is Allele, f'Expected parse("C*03:358") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:358") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_359():
    result = parse("C*03:359")
    assert result.__class__ is Allele, f'Expected parse("C*03:359") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:359") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_35_01():
    result = parse("C*03:35:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:35:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:35:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_35_02_01():
    result = parse("C*03:35:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:35:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:35:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_35_02_02():
    result = parse("C*03:35:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:35:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:35:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_36():
    result = parse("C*03:36")
    assert result.__class__ is Allele, f'Expected parse("C*03:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_360():
    result = parse("C*03:360")
    assert result.__class__ is Allele, f'Expected parse("C*03:360") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:360") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_361():
    result = parse("C*03:361")
    assert result.__class__ is Allele, f'Expected parse("C*03:361") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:361") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_362():
    result = parse("C*03:362")
    assert result.__class__ is Allele, f'Expected parse("C*03:362") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:362") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_363N():
    result = parse("C*03:363N")
    assert result.__class__ is Allele, f'Expected parse("C*03:363N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:363N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_364():
    result = parse("C*03:364")
    assert result.__class__ is Allele, f'Expected parse("C*03:364") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:364") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_365():
    result = parse("C*03:365")
    assert result.__class__ is Allele, f'Expected parse("C*03:365") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:365") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_366N():
    result = parse("C*03:366N")
    assert result.__class__ is Allele, f'Expected parse("C*03:366N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:366N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_367():
    result = parse("C*03:367")
    assert result.__class__ is Allele, f'Expected parse("C*03:367") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:367") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_368():
    result = parse("C*03:368")
    assert result.__class__ is Allele, f'Expected parse("C*03:368") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:368") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_369():
    result = parse("C*03:369")
    assert result.__class__ is Allele, f'Expected parse("C*03:369") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:369") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_370():
    result = parse("C*03:370")
    assert result.__class__ is Allele, f'Expected parse("C*03:370") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:370") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_371():
    result = parse("C*03:371")
    assert result.__class__ is Allele, f'Expected parse("C*03:371") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:371") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_372_01():
    result = parse("C*03:372:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:372:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:372:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_372_02():
    result = parse("C*03:372:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:372:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:372:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_373():
    result = parse("C*03:373")
    assert result.__class__ is Allele, f'Expected parse("C*03:373") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:373") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_374():
    result = parse("C*03:374")
    assert result.__class__ is Allele, f'Expected parse("C*03:374") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:374") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_375():
    result = parse("C*03:375")
    assert result.__class__ is Allele, f'Expected parse("C*03:375") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:375") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_376():
    result = parse("C*03:376")
    assert result.__class__ is Allele, f'Expected parse("C*03:376") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:376") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_377N():
    result = parse("C*03:377N")
    assert result.__class__ is Allele, f'Expected parse("C*03:377N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:377N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_378():
    result = parse("C*03:378")
    assert result.__class__ is Allele, f'Expected parse("C*03:378") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:378") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_379():
    result = parse("C*03:379")
    assert result.__class__ is Allele, f'Expected parse("C*03:379") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:379") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_37_01():
    result = parse("C*03:37:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:37:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:37:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_37_02():
    result = parse("C*03:37:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:37:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:37:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_380N():
    result = parse("C*03:380N")
    assert result.__class__ is Allele, f'Expected parse("C*03:380N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:380N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_381():
    result = parse("C*03:381")
    assert result.__class__ is Allele, f'Expected parse("C*03:381") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:381") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_382():
    result = parse("C*03:382")
    assert result.__class__ is Allele, f'Expected parse("C*03:382") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:382") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_383():
    result = parse("C*03:383")
    assert result.__class__ is Allele, f'Expected parse("C*03:383") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:383") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_384():
    result = parse("C*03:384")
    assert result.__class__ is Allele, f'Expected parse("C*03:384") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:384") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_385():
    result = parse("C*03:385")
    assert result.__class__ is Allele, f'Expected parse("C*03:385") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:385") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_386():
    result = parse("C*03:386")
    assert result.__class__ is Allele, f'Expected parse("C*03:386") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:386") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_387():
    result = parse("C*03:387")
    assert result.__class__ is Allele, f'Expected parse("C*03:387") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:387") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_388():
    result = parse("C*03:388")
    assert result.__class__ is Allele, f'Expected parse("C*03:388") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:388") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_389():
    result = parse("C*03:389")
    assert result.__class__ is Allele, f'Expected parse("C*03:389") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:389") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_38_01():
    result = parse("C*03:38:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:38:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:38:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_38_02():
    result = parse("C*03:38:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:38:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:38:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_39():
    result = parse("C*03:39")
    assert result.__class__ is Allele, f'Expected parse("C*03:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_390():
    result = parse("C*03:390")
    assert result.__class__ is Allele, f'Expected parse("C*03:390") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:390") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_391N():
    result = parse("C*03:391N")
    assert result.__class__ is Allele, f'Expected parse("C*03:391N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:391N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_392N():
    result = parse("C*03:392N")
    assert result.__class__ is Allele, f'Expected parse("C*03:392N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:392N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_393():
    result = parse("C*03:393")
    assert result.__class__ is Allele, f'Expected parse("C*03:393") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:393") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_394():
    result = parse("C*03:394")
    assert result.__class__ is Allele, f'Expected parse("C*03:394") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:394") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_395():
    result = parse("C*03:395")
    assert result.__class__ is Allele, f'Expected parse("C*03:395") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:395") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_396N():
    result = parse("C*03:396N")
    assert result.__class__ is Allele, f'Expected parse("C*03:396N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:396N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_397():
    result = parse("C*03:397")
    assert result.__class__ is Allele, f'Expected parse("C*03:397") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:397") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_398():
    result = parse("C*03:398")
    assert result.__class__ is Allele, f'Expected parse("C*03:398") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:398") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_399():
    result = parse("C*03:399")
    assert result.__class__ is Allele, f'Expected parse("C*03:399") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:399") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_400():
    result = parse("C*03:400")
    assert result.__class__ is Allele, f'Expected parse("C*03:400") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:400") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_401():
    result = parse("C*03:401")
    assert result.__class__ is Allele, f'Expected parse("C*03:401") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:401") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_402():
    result = parse("C*03:402")
    assert result.__class__ is Allele, f'Expected parse("C*03:402") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:402") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_403():
    result = parse("C*03:403")
    assert result.__class__ is Allele, f'Expected parse("C*03:403") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:403") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_404_01_01():
    result = parse("C*03:404:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:404:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:404:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_404_01_02():
    result = parse("C*03:404:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:404:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*03:404:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_405():
    result = parse("C*03:405")
    assert result.__class__ is Allele, f'Expected parse("C*03:405") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:405") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_406():
    result = parse("C*03:406")
    assert result.__class__ is Allele, f'Expected parse("C*03:406") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:406") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_407():
    result = parse("C*03:407")
    assert result.__class__ is Allele, f'Expected parse("C*03:407") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:407") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_408():
    result = parse("C*03:408")
    assert result.__class__ is Allele, f'Expected parse("C*03:408") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:408") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_409():
    result = parse("C*03:409")
    assert result.__class__ is Allele, f'Expected parse("C*03:409") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:409") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_40_01():
    result = parse("C*03:40:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:40:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:40:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_40_02():
    result = parse("C*03:40:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:40:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:40:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_40_03():
    result = parse("C*03:40:03")
    assert result.__class__ is Allele, f'Expected parse("C*03:40:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:40:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_40_04():
    result = parse("C*03:40:04")
    assert result.__class__ is Allele, f'Expected parse("C*03:40:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:40:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_410():
    result = parse("C*03:410")
    assert result.__class__ is Allele, f'Expected parse("C*03:410") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:410") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_411():
    result = parse("C*03:411")
    assert result.__class__ is Allele, f'Expected parse("C*03:411") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:411") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_412():
    result = parse("C*03:412")
    assert result.__class__ is Allele, f'Expected parse("C*03:412") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:412") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_413():
    result = parse("C*03:413")
    assert result.__class__ is Allele, f'Expected parse("C*03:413") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:413") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_414():
    result = parse("C*03:414")
    assert result.__class__ is Allele, f'Expected parse("C*03:414") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:414") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_415():
    result = parse("C*03:415")
    assert result.__class__ is Allele, f'Expected parse("C*03:415") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:415") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_416():
    result = parse("C*03:416")
    assert result.__class__ is Allele, f'Expected parse("C*03:416") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:416") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_417():
    result = parse("C*03:417")
    assert result.__class__ is Allele, f'Expected parse("C*03:417") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:417") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_418():
    result = parse("C*03:418")
    assert result.__class__ is Allele, f'Expected parse("C*03:418") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:418") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_419():
    result = parse("C*03:419")
    assert result.__class__ is Allele, f'Expected parse("C*03:419") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:419") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_41_01():
    result = parse("C*03:41:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:41:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:41:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_41_02():
    result = parse("C*03:41:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:41:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:41:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_420():
    result = parse("C*03:420")
    assert result.__class__ is Allele, f'Expected parse("C*03:420") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:420") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_421N():
    result = parse("C*03:421N")
    assert result.__class__ is Allele, f'Expected parse("C*03:421N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:421N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_422():
    result = parse("C*03:422")
    assert result.__class__ is Allele, f'Expected parse("C*03:422") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:422") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_423():
    result = parse("C*03:423")
    assert result.__class__ is Allele, f'Expected parse("C*03:423") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:423") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_424N():
    result = parse("C*03:424N")
    assert result.__class__ is Allele, f'Expected parse("C*03:424N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:424N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_425():
    result = parse("C*03:425")
    assert result.__class__ is Allele, f'Expected parse("C*03:425") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:425") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_426():
    result = parse("C*03:426")
    assert result.__class__ is Allele, f'Expected parse("C*03:426") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:426") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_427():
    result = parse("C*03:427")
    assert result.__class__ is Allele, f'Expected parse("C*03:427") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:427") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_428():
    result = parse("C*03:428")
    assert result.__class__ is Allele, f'Expected parse("C*03:428") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:428") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_429():
    result = parse("C*03:429")
    assert result.__class__ is Allele, f'Expected parse("C*03:429") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:429") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_42_01():
    result = parse("C*03:42:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:42:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:42:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_42_02():
    result = parse("C*03:42:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:42:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:42:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_430():
    result = parse("C*03:430")
    assert result.__class__ is Allele, f'Expected parse("C*03:430") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:430") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_431():
    result = parse("C*03:431")
    assert result.__class__ is Allele, f'Expected parse("C*03:431") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:431") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_432N():
    result = parse("C*03:432N")
    assert result.__class__ is Allele, f'Expected parse("C*03:432N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:432N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_433():
    result = parse("C*03:433")
    assert result.__class__ is Allele, f'Expected parse("C*03:433") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:433") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_434():
    result = parse("C*03:434")
    assert result.__class__ is Allele, f'Expected parse("C*03:434") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:434") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_435():
    result = parse("C*03:435")
    assert result.__class__ is Allele, f'Expected parse("C*03:435") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:435") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_436():
    result = parse("C*03:436")
    assert result.__class__ is Allele, f'Expected parse("C*03:436") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:436") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_437():
    result = parse("C*03:437")
    assert result.__class__ is Allele, f'Expected parse("C*03:437") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:437") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_438():
    result = parse("C*03:438")
    assert result.__class__ is Allele, f'Expected parse("C*03:438") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:438") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_439():
    result = parse("C*03:439")
    assert result.__class__ is Allele, f'Expected parse("C*03:439") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:439") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_43_01():
    result = parse("C*03:43:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:43:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:43:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_43_02():
    result = parse("C*03:43:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:43:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:43:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_44():
    result = parse("C*03:44")
    assert result.__class__ is Allele, f'Expected parse("C*03:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_440():
    result = parse("C*03:440")
    assert result.__class__ is Allele, f'Expected parse("C*03:440") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:440") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_441():
    result = parse("C*03:441")
    assert result.__class__ is Allele, f'Expected parse("C*03:441") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:441") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_442Q():
    result = parse("C*03:442Q")
    assert result.__class__ is Allele, f'Expected parse("C*03:442Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:442Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_443():
    result = parse("C*03:443")
    assert result.__class__ is Allele, f'Expected parse("C*03:443") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:443") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_444N():
    result = parse("C*03:444N")
    assert result.__class__ is Allele, f'Expected parse("C*03:444N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:444N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_445N():
    result = parse("C*03:445N")
    assert result.__class__ is Allele, f'Expected parse("C*03:445N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:445N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_446N():
    result = parse("C*03:446N")
    assert result.__class__ is Allele, f'Expected parse("C*03:446N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:446N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_447N():
    result = parse("C*03:447N")
    assert result.__class__ is Allele, f'Expected parse("C*03:447N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:447N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_448Q():
    result = parse("C*03:448Q")
    assert result.__class__ is Allele, f'Expected parse("C*03:448Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:448Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_449N():
    result = parse("C*03:449N")
    assert result.__class__ is Allele, f'Expected parse("C*03:449N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:449N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_45():
    result = parse("C*03:45")
    assert result.__class__ is Allele, f'Expected parse("C*03:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_450():
    result = parse("C*03:450")
    assert result.__class__ is Allele, f'Expected parse("C*03:450") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:450") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_451():
    result = parse("C*03:451")
    assert result.__class__ is Allele, f'Expected parse("C*03:451") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:451") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_452():
    result = parse("C*03:452")
    assert result.__class__ is Allele, f'Expected parse("C*03:452") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:452") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_453():
    result = parse("C*03:453")
    assert result.__class__ is Allele, f'Expected parse("C*03:453") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:453") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_454():
    result = parse("C*03:454")
    assert result.__class__ is Allele, f'Expected parse("C*03:454") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:454") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_455():
    result = parse("C*03:455")
    assert result.__class__ is Allele, f'Expected parse("C*03:455") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:455") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_456():
    result = parse("C*03:456")
    assert result.__class__ is Allele, f'Expected parse("C*03:456") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:456") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_457():
    result = parse("C*03:457")
    assert result.__class__ is Allele, f'Expected parse("C*03:457") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:457") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_458():
    result = parse("C*03:458")
    assert result.__class__ is Allele, f'Expected parse("C*03:458") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:458") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_459():
    result = parse("C*03:459")
    assert result.__class__ is Allele, f'Expected parse("C*03:459") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:459") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_46():
    result = parse("C*03:46")
    assert result.__class__ is Allele, f'Expected parse("C*03:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_460():
    result = parse("C*03:460")
    assert result.__class__ is Allele, f'Expected parse("C*03:460") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:460") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_461():
    result = parse("C*03:461")
    assert result.__class__ is Allele, f'Expected parse("C*03:461") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:461") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_462N():
    result = parse("C*03:462N")
    assert result.__class__ is Allele, f'Expected parse("C*03:462N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:462N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_463N():
    result = parse("C*03:463N")
    assert result.__class__ is Allele, f'Expected parse("C*03:463N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:463N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_464():
    result = parse("C*03:464")
    assert result.__class__ is Allele, f'Expected parse("C*03:464") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:464") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_465():
    result = parse("C*03:465")
    assert result.__class__ is Allele, f'Expected parse("C*03:465") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:465") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_466():
    result = parse("C*03:466")
    assert result.__class__ is Allele, f'Expected parse("C*03:466") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:466") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_467():
    result = parse("C*03:467")
    assert result.__class__ is Allele, f'Expected parse("C*03:467") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:467") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_468():
    result = parse("C*03:468")
    assert result.__class__ is Allele, f'Expected parse("C*03:468") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:468") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_469():
    result = parse("C*03:469")
    assert result.__class__ is Allele, f'Expected parse("C*03:469") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:469") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_47():
    result = parse("C*03:47")
    assert result.__class__ is Allele, f'Expected parse("C*03:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_470N():
    result = parse("C*03:470N")
    assert result.__class__ is Allele, f'Expected parse("C*03:470N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:470N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_471():
    result = parse("C*03:471")
    assert result.__class__ is Allele, f'Expected parse("C*03:471") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:471") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_472():
    result = parse("C*03:472")
    assert result.__class__ is Allele, f'Expected parse("C*03:472") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:472") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_473():
    result = parse("C*03:473")
    assert result.__class__ is Allele, f'Expected parse("C*03:473") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:473") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_474():
    result = parse("C*03:474")
    assert result.__class__ is Allele, f'Expected parse("C*03:474") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:474") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_475():
    result = parse("C*03:475")
    assert result.__class__ is Allele, f'Expected parse("C*03:475") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:475") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_476():
    result = parse("C*03:476")
    assert result.__class__ is Allele, f'Expected parse("C*03:476") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:476") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_477():
    result = parse("C*03:477")
    assert result.__class__ is Allele, f'Expected parse("C*03:477") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:477") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_478():
    result = parse("C*03:478")
    assert result.__class__ is Allele, f'Expected parse("C*03:478") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:478") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_479():
    result = parse("C*03:479")
    assert result.__class__ is Allele, f'Expected parse("C*03:479") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:479") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_48():
    result = parse("C*03:48")
    assert result.__class__ is Allele, f'Expected parse("C*03:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_480():
    result = parse("C*03:480")
    assert result.__class__ is Allele, f'Expected parse("C*03:480") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:480") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_481():
    result = parse("C*03:481")
    assert result.__class__ is Allele, f'Expected parse("C*03:481") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:481") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_482():
    result = parse("C*03:482")
    assert result.__class__ is Allele, f'Expected parse("C*03:482") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:482") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_483():
    result = parse("C*03:483")
    assert result.__class__ is Allele, f'Expected parse("C*03:483") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:483") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_484():
    result = parse("C*03:484")
    assert result.__class__ is Allele, f'Expected parse("C*03:484") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:484") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_485():
    result = parse("C*03:485")
    assert result.__class__ is Allele, f'Expected parse("C*03:485") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:485") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_486():
    result = parse("C*03:486")
    assert result.__class__ is Allele, f'Expected parse("C*03:486") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:486") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_487():
    result = parse("C*03:487")
    assert result.__class__ is Allele, f'Expected parse("C*03:487") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:487") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_488():
    result = parse("C*03:488")
    assert result.__class__ is Allele, f'Expected parse("C*03:488") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:488") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_489():
    result = parse("C*03:489")
    assert result.__class__ is Allele, f'Expected parse("C*03:489") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:489") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_49():
    result = parse("C*03:49")
    assert result.__class__ is Allele, f'Expected parse("C*03:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_490():
    result = parse("C*03:490")
    assert result.__class__ is Allele, f'Expected parse("C*03:490") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:490") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_491_01():
    result = parse("C*03:491:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:491:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:491:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_491_02():
    result = parse("C*03:491:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*03:491:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:491:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_492():
    result = parse("C*03:492")
    assert result.__class__ is Allele, f'Expected parse("C*03:492") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:492") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_493():
    result = parse("C*03:493")
    assert result.__class__ is Allele, f'Expected parse("C*03:493") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:493") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_494():
    result = parse("C*03:494")
    assert result.__class__ is Allele, f'Expected parse("C*03:494") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:494") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_495():
    result = parse("C*03:495")
    assert result.__class__ is Allele, f'Expected parse("C*03:495") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:495") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_496():
    result = parse("C*03:496")
    assert result.__class__ is Allele, f'Expected parse("C*03:496") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:496") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_497():
    result = parse("C*03:497")
    assert result.__class__ is Allele, f'Expected parse("C*03:497") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:497") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_498():
    result = parse("C*03:498")
    assert result.__class__ is Allele, f'Expected parse("C*03:498") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:498") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_499():
    result = parse("C*03:499")
    assert result.__class__ is Allele, f'Expected parse("C*03:499") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:499") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_50():
    result = parse("C*03:50")
    assert result.__class__ is Allele, f'Expected parse("C*03:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_500():
    result = parse("C*03:500")
    assert result.__class__ is Allele, f'Expected parse("C*03:500") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:500") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_501():
    result = parse("C*03:501")
    assert result.__class__ is Allele, f'Expected parse("C*03:501") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:501") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_502():
    result = parse("C*03:502")
    assert result.__class__ is Allele, f'Expected parse("C*03:502") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:502") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_503():
    result = parse("C*03:503")
    assert result.__class__ is Allele, f'Expected parse("C*03:503") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:503") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_504():
    result = parse("C*03:504")
    assert result.__class__ is Allele, f'Expected parse("C*03:504") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:504") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_505():
    result = parse("C*03:505")
    assert result.__class__ is Allele, f'Expected parse("C*03:505") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:505") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_506():
    result = parse("C*03:506")
    assert result.__class__ is Allele, f'Expected parse("C*03:506") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:506") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_507():
    result = parse("C*03:507")
    assert result.__class__ is Allele, f'Expected parse("C*03:507") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:507") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_508N():
    result = parse("C*03:508N")
    assert result.__class__ is Allele, f'Expected parse("C*03:508N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:508N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_509N():
    result = parse("C*03:509N")
    assert result.__class__ is Allele, f'Expected parse("C*03:509N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:509N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_51():
    result = parse("C*03:51")
    assert result.__class__ is Allele, f'Expected parse("C*03:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_510N():
    result = parse("C*03:510N")
    assert result.__class__ is Allele, f'Expected parse("C*03:510N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:510N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_511N():
    result = parse("C*03:511N")
    assert result.__class__ is Allele, f'Expected parse("C*03:511N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:511N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_512():
    result = parse("C*03:512")
    assert result.__class__ is Allele, f'Expected parse("C*03:512") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:512") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_513():
    result = parse("C*03:513")
    assert result.__class__ is Allele, f'Expected parse("C*03:513") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:513") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_514():
    result = parse("C*03:514")
    assert result.__class__ is Allele, f'Expected parse("C*03:514") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:514") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_515():
    result = parse("C*03:515")
    assert result.__class__ is Allele, f'Expected parse("C*03:515") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:515") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_516():
    result = parse("C*03:516")
    assert result.__class__ is Allele, f'Expected parse("C*03:516") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:516") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_517():
    result = parse("C*03:517")
    assert result.__class__ is Allele, f'Expected parse("C*03:517") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:517") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_518():
    result = parse("C*03:518")
    assert result.__class__ is Allele, f'Expected parse("C*03:518") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:518") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_519():
    result = parse("C*03:519")
    assert result.__class__ is Allele, f'Expected parse("C*03:519") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:519") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_52():
    result = parse("C*03:52")
    assert result.__class__ is Allele, f'Expected parse("C*03:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_520():
    result = parse("C*03:520")
    assert result.__class__ is Allele, f'Expected parse("C*03:520") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:520") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_521():
    result = parse("C*03:521")
    assert result.__class__ is Allele, f'Expected parse("C*03:521") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:521") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_522():
    result = parse("C*03:522")
    assert result.__class__ is Allele, f'Expected parse("C*03:522") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:522") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_523():
    result = parse("C*03:523")
    assert result.__class__ is Allele, f'Expected parse("C*03:523") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:523") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_524():
    result = parse("C*03:524")
    assert result.__class__ is Allele, f'Expected parse("C*03:524") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:524") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_525():
    result = parse("C*03:525")
    assert result.__class__ is Allele, f'Expected parse("C*03:525") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:525") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_526():
    result = parse("C*03:526")
    assert result.__class__ is Allele, f'Expected parse("C*03:526") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:526") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_527():
    result = parse("C*03:527")
    assert result.__class__ is Allele, f'Expected parse("C*03:527") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:527") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_528():
    result = parse("C*03:528")
    assert result.__class__ is Allele, f'Expected parse("C*03:528") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:528") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_529():
    result = parse("C*03:529")
    assert result.__class__ is Allele, f'Expected parse("C*03:529") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:529") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_53():
    result = parse("C*03:53")
    assert result.__class__ is Allele, f'Expected parse("C*03:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_54():
    result = parse("C*03:54")
    assert result.__class__ is Allele, f'Expected parse("C*03:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_55():
    result = parse("C*03:55")
    assert result.__class__ is Allele, f'Expected parse("C*03:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_56():
    result = parse("C*03:56")
    assert result.__class__ is Allele, f'Expected parse("C*03:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_57_01():
    result = parse("C*03:57:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:57:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:57:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_57_02():
    result = parse("C*03:57:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:57:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:57:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_58():
    result = parse("C*03:58")
    assert result.__class__ is Allele, f'Expected parse("C*03:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_59():
    result = parse("C*03:59")
    assert result.__class__ is Allele, f'Expected parse("C*03:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_60():
    result = parse("C*03:60")
    assert result.__class__ is Allele, f'Expected parse("C*03:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_61():
    result = parse("C*03:61")
    assert result.__class__ is Allele, f'Expected parse("C*03:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_62():
    result = parse("C*03:62")
    assert result.__class__ is Allele, f'Expected parse("C*03:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_63():
    result = parse("C*03:63")
    assert result.__class__ is Allele, f'Expected parse("C*03:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_64_01():
    result = parse("C*03:64:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:64:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:64:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_64_02():
    result = parse("C*03:64:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:64:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:64:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_65():
    result = parse("C*03:65")
    assert result.__class__ is Allele, f'Expected parse("C*03:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_66():
    result = parse("C*03:66")
    assert result.__class__ is Allele, f'Expected parse("C*03:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_67():
    result = parse("C*03:67")
    assert result.__class__ is Allele, f'Expected parse("C*03:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_68():
    result = parse("C*03:68")
    assert result.__class__ is Allele, f'Expected parse("C*03:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_69():
    result = parse("C*03:69")
    assert result.__class__ is Allele, f'Expected parse("C*03:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_70():
    result = parse("C*03:70")
    assert result.__class__ is Allele, f'Expected parse("C*03:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_71():
    result = parse("C*03:71")
    assert result.__class__ is Allele, f'Expected parse("C*03:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_72():
    result = parse("C*03:72")
    assert result.__class__ is Allele, f'Expected parse("C*03:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_73():
    result = parse("C*03:73")
    assert result.__class__ is Allele, f'Expected parse("C*03:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_74():
    result = parse("C*03:74")
    assert result.__class__ is Allele, f'Expected parse("C*03:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_75():
    result = parse("C*03:75")
    assert result.__class__ is Allele, f'Expected parse("C*03:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_76():
    result = parse("C*03:76")
    assert result.__class__ is Allele, f'Expected parse("C*03:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_77():
    result = parse("C*03:77")
    assert result.__class__ is Allele, f'Expected parse("C*03:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_78():
    result = parse("C*03:78")
    assert result.__class__ is Allele, f'Expected parse("C*03:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_79():
    result = parse("C*03:79")
    assert result.__class__ is Allele, f'Expected parse("C*03:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_80_01():
    result = parse("C*03:80:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:80:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:80:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_80_02():
    result = parse("C*03:80:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:80:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:80:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_81():
    result = parse("C*03:81")
    assert result.__class__ is Allele, f'Expected parse("C*03:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_82():
    result = parse("C*03:82")
    assert result.__class__ is Allele, f'Expected parse("C*03:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_83():
    result = parse("C*03:83")
    assert result.__class__ is Allele, f'Expected parse("C*03:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_84():
    result = parse("C*03:84")
    assert result.__class__ is Allele, f'Expected parse("C*03:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_85():
    result = parse("C*03:85")
    assert result.__class__ is Allele, f'Expected parse("C*03:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_86():
    result = parse("C*03:86")
    assert result.__class__ is Allele, f'Expected parse("C*03:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_87_01():
    result = parse("C*03:87:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:87:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:87:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_87_02():
    result = parse("C*03:87:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:87:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:87:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_88():
    result = parse("C*03:88")
    assert result.__class__ is Allele, f'Expected parse("C*03:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_89():
    result = parse("C*03:89")
    assert result.__class__ is Allele, f'Expected parse("C*03:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_90():
    result = parse("C*03:90")
    assert result.__class__ is Allele, f'Expected parse("C*03:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_91_01():
    result = parse("C*03:91:01")
    assert result.__class__ is Allele, f'Expected parse("C*03:91:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:91:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_91_02():
    result = parse("C*03:91:02")
    assert result.__class__ is Allele, f'Expected parse("C*03:91:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*03:91:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_92():
    result = parse("C*03:92")
    assert result.__class__ is Allele, f'Expected parse("C*03:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_93():
    result = parse("C*03:93")
    assert result.__class__ is Allele, f'Expected parse("C*03:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_94():
    result = parse("C*03:94")
    assert result.__class__ is Allele, f'Expected parse("C*03:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_95():
    result = parse("C*03:95")
    assert result.__class__ is Allele, f'Expected parse("C*03:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_96():
    result = parse("C*03:96")
    assert result.__class__ is Allele, f'Expected parse("C*03:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_97():
    result = parse("C*03:97")
    assert result.__class__ is Allele, f'Expected parse("C*03:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_03_98():
    result = parse("C*03:98")
    assert result.__class__ is Allele, f'Expected parse("C*03:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*03:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_01():
    result = parse("C*04:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_02():
    result = parse("C*04:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_03():
    result = parse("C*04:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_04():
    result = parse("C*04:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_05():
    result = parse("C*04:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_06():
    result = parse("C*04:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_07():
    result = parse("C*04:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_08():
    result = parse("C*04:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_09():
    result = parse("C*04:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_10():
    result = parse("C*04:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_100():
    result = parse("C*04:01:01:100")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:100") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_11():
    result = parse("C*04:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_12():
    result = parse("C*04:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_13():
    result = parse("C*04:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_14():
    result = parse("C*04:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_15():
    result = parse("C*04:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_16():
    result = parse("C*04:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_17():
    result = parse("C*04:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_18():
    result = parse("C*04:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_19():
    result = parse("C*04:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_20():
    result = parse("C*04:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_21():
    result = parse("C*04:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_22():
    result = parse("C*04:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_23():
    result = parse("C*04:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_24():
    result = parse("C*04:01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_25():
    result = parse("C*04:01:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_26():
    result = parse("C*04:01:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_27():
    result = parse("C*04:01:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_28():
    result = parse("C*04:01:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_29():
    result = parse("C*04:01:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_31():
    result = parse("C*04:01:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_32():
    result = parse("C*04:01:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_33():
    result = parse("C*04:01:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_34():
    result = parse("C*04:01:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_35():
    result = parse("C*04:01:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_36():
    result = parse("C*04:01:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_37():
    result = parse("C*04:01:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_38():
    result = parse("C*04:01:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_39():
    result = parse("C*04:01:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_40():
    result = parse("C*04:01:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_41():
    result = parse("C*04:01:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_42():
    result = parse("C*04:01:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_43():
    result = parse("C*04:01:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_44():
    result = parse("C*04:01:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_45():
    result = parse("C*04:01:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:45") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_46():
    result = parse("C*04:01:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:46") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_47Q():
    result = parse("C*04:01:01:47Q")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:47Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:47Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_48():
    result = parse("C*04:01:01:48")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:48") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:48") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_49():
    result = parse("C*04:01:01:49")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:49") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:49") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_50():
    result = parse("C*04:01:01:50")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:50") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:50") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_51():
    result = parse("C*04:01:01:51")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:51") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:51") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_52():
    result = parse("C*04:01:01:52")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:52") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:52") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_53():
    result = parse("C*04:01:01:53")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:53") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:53") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_54():
    result = parse("C*04:01:01:54")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:54") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:54") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_55():
    result = parse("C*04:01:01:55")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:55") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:55") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_56():
    result = parse("C*04:01:01:56")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:56") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:56") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_57():
    result = parse("C*04:01:01:57")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:57") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:57") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_58():
    result = parse("C*04:01:01:58")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:58") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:58") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_59():
    result = parse("C*04:01:01:59")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:59") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:59") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_60():
    result = parse("C*04:01:01:60")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:60") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:60") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_61():
    result = parse("C*04:01:01:61")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:61") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:61") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_62():
    result = parse("C*04:01:01:62")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:62") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:62") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_63():
    result = parse("C*04:01:01:63")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:63") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:63") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_64():
    result = parse("C*04:01:01:64")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:64") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:64") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_65():
    result = parse("C*04:01:01:65")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:65") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:65") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_66():
    result = parse("C*04:01:01:66")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:66") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:66") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_67():
    result = parse("C*04:01:01:67")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:67") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:67") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_68():
    result = parse("C*04:01:01:68")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:68") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:68") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_69():
    result = parse("C*04:01:01:69")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:69") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:69") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_70():
    result = parse("C*04:01:01:70")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:70") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:70") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_71():
    result = parse("C*04:01:01:71")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:71") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:71") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_72():
    result = parse("C*04:01:01:72")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:72") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:72") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_73():
    result = parse("C*04:01:01:73")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:73") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:73") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_74():
    result = parse("C*04:01:01:74")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:74") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:74") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_75():
    result = parse("C*04:01:01:75")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:75") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:75") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_76():
    result = parse("C*04:01:01:76")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:76") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:76") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_77():
    result = parse("C*04:01:01:77")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:77") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:77") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_78():
    result = parse("C*04:01:01:78")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:78") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:78") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_79():
    result = parse("C*04:01:01:79")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:79") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:79") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_80():
    result = parse("C*04:01:01:80")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:80") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:80") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_81():
    result = parse("C*04:01:01:81")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:81") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:81") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_82():
    result = parse("C*04:01:01:82")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:82") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:82") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_83():
    result = parse("C*04:01:01:83")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:83") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:83") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_84Q():
    result = parse("C*04:01:01:84Q")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:84Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:84Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_85():
    result = parse("C*04:01:01:85")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:85") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:85") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_86():
    result = parse("C*04:01:01:86")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:86") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:86") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_87():
    result = parse("C*04:01:01:87")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:87") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:87") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_88():
    result = parse("C*04:01:01:88")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:88") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:88") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_89():
    result = parse("C*04:01:01:89")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:89") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:89") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_90():
    result = parse("C*04:01:01:90")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:90") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:90") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_91():
    result = parse("C*04:01:01:91")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:91") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:91") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_92():
    result = parse("C*04:01:01:92")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:92") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:92") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_93():
    result = parse("C*04:01:01:93")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:93") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:93") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_94():
    result = parse("C*04:01:01:94")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:94") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:94") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_95():
    result = parse("C*04:01:01:95")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:95") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:95") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_96():
    result = parse("C*04:01:01:96")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:96") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:96") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_97():
    result = parse("C*04:01:01:97")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:97") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:97") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_98():
    result = parse("C*04:01:01:98")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:98") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:98") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_01_99():
    result = parse("C*04:01:01:99")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:01:99") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:01:99") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_02():
    result = parse("C*04:01:02")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_03():
    result = parse("C*04:01:03")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_04():
    result = parse("C*04:01:04")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_05():
    result = parse("C*04:01:05")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_06():
    result = parse("C*04:01:06")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_07():
    result = parse("C*04:01:07")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_08():
    result = parse("C*04:01:08")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_09():
    result = parse("C*04:01:09")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_10():
    result = parse("C*04:01:10")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_100():
    result = parse("C*04:01:100")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:100") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_101():
    result = parse("C*04:01:101")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:101") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_102():
    result = parse("C*04:01:102")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:102") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_103():
    result = parse("C*04:01:103")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:103") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_104():
    result = parse("C*04:01:104")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:104") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_105():
    result = parse("C*04:01:105")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:105") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_106_01():
    result = parse("C*04:01:106:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:106:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:106:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_106_02():
    result = parse("C*04:01:106:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:106:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:106:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_107():
    result = parse("C*04:01:107")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:107") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_108():
    result = parse("C*04:01:108")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:108") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_109():
    result = parse("C*04:01:109")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:109") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_11():
    result = parse("C*04:01:11")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_110():
    result = parse("C*04:01:110")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:110") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_111():
    result = parse("C*04:01:111")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:111") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_112():
    result = parse("C*04:01:112")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:112") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_113():
    result = parse("C*04:01:113")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:113") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_114():
    result = parse("C*04:01:114")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:114") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_115():
    result = parse("C*04:01:115")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:115") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:115") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_116():
    result = parse("C*04:01:116")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:116") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_117():
    result = parse("C*04:01:117")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:117") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_118():
    result = parse("C*04:01:118")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:118") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:118") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_119():
    result = parse("C*04:01:119")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:119") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:119") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_12():
    result = parse("C*04:01:12")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_120():
    result = parse("C*04:01:120")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:120") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:120") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_121():
    result = parse("C*04:01:121")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:121") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:121") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_122():
    result = parse("C*04:01:122")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:122") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:122") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_123():
    result = parse("C*04:01:123")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:123") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:123") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_124():
    result = parse("C*04:01:124")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:124") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:124") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_125():
    result = parse("C*04:01:125")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:125") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:125") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_126():
    result = parse("C*04:01:126")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:126") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:126") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_127():
    result = parse("C*04:01:127")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:127") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:127") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_128():
    result = parse("C*04:01:128")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:128") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:128") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_129():
    result = parse("C*04:01:129")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:129") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:129") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_13():
    result = parse("C*04:01:13")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_14():
    result = parse("C*04:01:14")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_15():
    result = parse("C*04:01:15")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_16():
    result = parse("C*04:01:16")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_17():
    result = parse("C*04:01:17")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_18():
    result = parse("C*04:01:18")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_19():
    result = parse("C*04:01:19")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_20():
    result = parse("C*04:01:20")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_21():
    result = parse("C*04:01:21")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_22():
    result = parse("C*04:01:22")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_23():
    result = parse("C*04:01:23")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_24():
    result = parse("C*04:01:24")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_25():
    result = parse("C*04:01:25")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_26():
    result = parse("C*04:01:26")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_27():
    result = parse("C*04:01:27")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_28():
    result = parse("C*04:01:28")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_29():
    result = parse("C*04:01:29")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_30():
    result = parse("C*04:01:30")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_31():
    result = parse("C*04:01:31")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_32():
    result = parse("C*04:01:32")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_33():
    result = parse("C*04:01:33")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_34():
    result = parse("C*04:01:34")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_35():
    result = parse("C*04:01:35")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_36():
    result = parse("C*04:01:36")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_37():
    result = parse("C*04:01:37")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_38():
    result = parse("C*04:01:38")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_39():
    result = parse("C*04:01:39")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_40():
    result = parse("C*04:01:40")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_41():
    result = parse("C*04:01:41")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_42():
    result = parse("C*04:01:42")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_43():
    result = parse("C*04:01:43")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_44():
    result = parse("C*04:01:44")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_45():
    result = parse("C*04:01:45")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_46():
    result = parse("C*04:01:46")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_47():
    result = parse("C*04:01:47")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_48():
    result = parse("C*04:01:48")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_49():
    result = parse("C*04:01:49")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_50():
    result = parse("C*04:01:50")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_51():
    result = parse("C*04:01:51")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_52():
    result = parse("C*04:01:52")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_53():
    result = parse("C*04:01:53")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_54():
    result = parse("C*04:01:54")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_55():
    result = parse("C*04:01:55")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_56():
    result = parse("C*04:01:56")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_57():
    result = parse("C*04:01:57")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_58():
    result = parse("C*04:01:58")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_59():
    result = parse("C*04:01:59")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_60():
    result = parse("C*04:01:60")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_61():
    result = parse("C*04:01:61")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_62():
    result = parse("C*04:01:62")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_63():
    result = parse("C*04:01:63")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_64():
    result = parse("C*04:01:64")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_65():
    result = parse("C*04:01:65")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_66():
    result = parse("C*04:01:66")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:66") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:66") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_67():
    result = parse("C*04:01:67")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:67") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:67") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_68():
    result = parse("C*04:01:68")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:68") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:68") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_69():
    result = parse("C*04:01:69")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:69") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:69") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_70():
    result = parse("C*04:01:70")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:70") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:70") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_71():
    result = parse("C*04:01:71")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:71") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:71") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_72():
    result = parse("C*04:01:72")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:72") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:72") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_73():
    result = parse("C*04:01:73")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:73") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:73") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_74():
    result = parse("C*04:01:74")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:74") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:74") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_75():
    result = parse("C*04:01:75")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:75") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:75") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_76():
    result = parse("C*04:01:76")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:76") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:76") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_77():
    result = parse("C*04:01:77")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:77") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:77") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_78():
    result = parse("C*04:01:78")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:78") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:78") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_79():
    result = parse("C*04:01:79")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:79") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:79") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_80():
    result = parse("C*04:01:80")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:80") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:80") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_81():
    result = parse("C*04:01:81")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:81") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:81") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_82_01():
    result = parse("C*04:01:82:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:82:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:82:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_82_02():
    result = parse("C*04:01:82:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:82:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:82:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_82_03():
    result = parse("C*04:01:82:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:82:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:82:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_83():
    result = parse("C*04:01:83")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:83") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:83") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_84():
    result = parse("C*04:01:84")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:84") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:84") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_85():
    result = parse("C*04:01:85")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:85") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:85") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_86():
    result = parse("C*04:01:86")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:86") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:86") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_87():
    result = parse("C*04:01:87")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:87") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:87") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_88():
    result = parse("C*04:01:88")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:88") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:88") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_89():
    result = parse("C*04:01:89")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:89") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:89") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_90():
    result = parse("C*04:01:90")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:90") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:90") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_91():
    result = parse("C*04:01:91")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:91") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:91") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_92_01():
    result = parse("C*04:01:92:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:92:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:92:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_92_02():
    result = parse("C*04:01:92:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:92:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:92:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_92_03():
    result = parse("C*04:01:92:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:01:92:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:01:92:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_93():
    result = parse("C*04:01:93")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:93") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:93") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_94():
    result = parse("C*04:01:94")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:94") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:94") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_95():
    result = parse("C*04:01:95")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:95") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:95") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_96():
    result = parse("C*04:01:96")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:96") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:96") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_97():
    result = parse("C*04:01:97")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:97") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:97") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_98():
    result = parse("C*04:01:98")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:98") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:98") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_01_99():
    result = parse("C*04:01:99")
    assert result.__class__ is Allele, f'Expected parse("C*04:01:99") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:01:99") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_03_01_01():
    result = parse("C*04:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_03_01_02():
    result = parse("C*04:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_03_02():
    result = parse("C*04:03:02")
    assert result.__class__ is Allele, f'Expected parse("C*04:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_03_03():
    result = parse("C*04:03:03")
    assert result.__class__ is Allele, f'Expected parse("C*04:03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_03_04():
    result = parse("C*04:03:04")
    assert result.__class__ is Allele, f'Expected parse("C*04:03:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_03_05():
    result = parse("C*04:03:05")
    assert result.__class__ is Allele, f'Expected parse("C*04:03:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_03_06():
    result = parse("C*04:03:06")
    assert result.__class__ is Allele, f'Expected parse("C*04:03:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_03_07():
    result = parse("C*04:03:07")
    assert result.__class__ is Allele, f'Expected parse("C*04:03:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_04_01_01():
    result = parse("C*04:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_04_01_02():
    result = parse("C*04:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_04_02():
    result = parse("C*04:04:02")
    assert result.__class__ is Allele, f'Expected parse("C*04:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_05():
    result = parse("C*04:05")
    assert result.__class__ is Allele, f'Expected parse("C*04:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_06_01():
    result = parse("C*04:06:01")
    assert result.__class__ is Allele, f'Expected parse("C*04:06:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_06_02():
    result = parse("C*04:06:02")
    assert result.__class__ is Allele, f'Expected parse("C*04:06:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_06_03():
    result = parse("C*04:06:03")
    assert result.__class__ is Allele, f'Expected parse("C*04:06:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:06:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_07_01():
    result = parse("C*04:07:01")
    assert result.__class__ is Allele, f'Expected parse("C*04:07:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_07_02():
    result = parse("C*04:07:02")
    assert result.__class__ is Allele, f'Expected parse("C*04:07:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_08():
    result = parse("C*04:08")
    assert result.__class__ is Allele, f'Expected parse("C*04:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_09N():
    result = parse("C*04:09N")
    assert result.__class__ is Allele, f'Expected parse("C*04:09N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:09N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_10():
    result = parse("C*04:10")
    assert result.__class__ is Allele, f'Expected parse("C*04:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_100():
    result = parse("C*04:100")
    assert result.__class__ is Allele, f'Expected parse("C*04:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_101():
    result = parse("C*04:101")
    assert result.__class__ is Allele, f'Expected parse("C*04:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_102():
    result = parse("C*04:102")
    assert result.__class__ is Allele, f'Expected parse("C*04:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_103_01():
    result = parse("C*04:103:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:103:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:103:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_103_02():
    result = parse("C*04:103:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:103:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:103:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_104():
    result = parse("C*04:104")
    assert result.__class__ is Allele, f'Expected parse("C*04:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_105N():
    result = parse("C*04:105N")
    assert result.__class__ is Allele, f'Expected parse("C*04:105N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:105N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_106():
    result = parse("C*04:106")
    assert result.__class__ is Allele, f'Expected parse("C*04:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_107():
    result = parse("C*04:107")
    assert result.__class__ is Allele, f'Expected parse("C*04:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_108():
    result = parse("C*04:108")
    assert result.__class__ is Allele, f'Expected parse("C*04:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_109():
    result = parse("C*04:109")
    assert result.__class__ is Allele, f'Expected parse("C*04:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_11():
    result = parse("C*04:11")
    assert result.__class__ is Allele, f'Expected parse("C*04:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_110():
    result = parse("C*04:110")
    assert result.__class__ is Allele, f'Expected parse("C*04:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_111():
    result = parse("C*04:111")
    assert result.__class__ is Allele, f'Expected parse("C*04:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_112():
    result = parse("C*04:112")
    assert result.__class__ is Allele, f'Expected parse("C*04:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_113():
    result = parse("C*04:113")
    assert result.__class__ is Allele, f'Expected parse("C*04:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_114():
    result = parse("C*04:114")
    assert result.__class__ is Allele, f'Expected parse("C*04:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_115N():
    result = parse("C*04:115N")
    assert result.__class__ is Allele, f'Expected parse("C*04:115N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:115N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_116():
    result = parse("C*04:116")
    assert result.__class__ is Allele, f'Expected parse("C*04:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_117():
    result = parse("C*04:117")
    assert result.__class__ is Allele, f'Expected parse("C*04:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_118():
    result = parse("C*04:118")
    assert result.__class__ is Allele, f'Expected parse("C*04:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_119():
    result = parse("C*04:119")
    assert result.__class__ is Allele, f'Expected parse("C*04:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_12():
    result = parse("C*04:12")
    assert result.__class__ is Allele, f'Expected parse("C*04:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_120():
    result = parse("C*04:120")
    assert result.__class__ is Allele, f'Expected parse("C*04:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_121():
    result = parse("C*04:121")
    assert result.__class__ is Allele, f'Expected parse("C*04:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_122():
    result = parse("C*04:122")
    assert result.__class__ is Allele, f'Expected parse("C*04:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_123N():
    result = parse("C*04:123N")
    assert result.__class__ is Allele, f'Expected parse("C*04:123N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:123N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_124():
    result = parse("C*04:124")
    assert result.__class__ is Allele, f'Expected parse("C*04:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_125():
    result = parse("C*04:125")
    assert result.__class__ is Allele, f'Expected parse("C*04:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_126():
    result = parse("C*04:126")
    assert result.__class__ is Allele, f'Expected parse("C*04:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_127():
    result = parse("C*04:127")
    assert result.__class__ is Allele, f'Expected parse("C*04:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_128():
    result = parse("C*04:128")
    assert result.__class__ is Allele, f'Expected parse("C*04:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_129():
    result = parse("C*04:129")
    assert result.__class__ is Allele, f'Expected parse("C*04:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_130():
    result = parse("C*04:130")
    assert result.__class__ is Allele, f'Expected parse("C*04:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_131():
    result = parse("C*04:131")
    assert result.__class__ is Allele, f'Expected parse("C*04:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_132():
    result = parse("C*04:132")
    assert result.__class__ is Allele, f'Expected parse("C*04:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_133():
    result = parse("C*04:133")
    assert result.__class__ is Allele, f'Expected parse("C*04:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_134():
    result = parse("C*04:134")
    assert result.__class__ is Allele, f'Expected parse("C*04:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_135():
    result = parse("C*04:135")
    assert result.__class__ is Allele, f'Expected parse("C*04:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_136():
    result = parse("C*04:136")
    assert result.__class__ is Allele, f'Expected parse("C*04:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_137():
    result = parse("C*04:137")
    assert result.__class__ is Allele, f'Expected parse("C*04:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_138():
    result = parse("C*04:138")
    assert result.__class__ is Allele, f'Expected parse("C*04:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_139():
    result = parse("C*04:139")
    assert result.__class__ is Allele, f'Expected parse("C*04:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_13_01_01():
    result = parse("C*04:13:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:13:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:13:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_13_01_02():
    result = parse("C*04:13:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:13:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:13:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_14():
    result = parse("C*04:14")
    assert result.__class__ is Allele, f'Expected parse("C*04:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_140():
    result = parse("C*04:140")
    assert result.__class__ is Allele, f'Expected parse("C*04:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_141():
    result = parse("C*04:141")
    assert result.__class__ is Allele, f'Expected parse("C*04:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_142():
    result = parse("C*04:142")
    assert result.__class__ is Allele, f'Expected parse("C*04:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_143():
    result = parse("C*04:143")
    assert result.__class__ is Allele, f'Expected parse("C*04:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_144():
    result = parse("C*04:144")
    assert result.__class__ is Allele, f'Expected parse("C*04:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_145():
    result = parse("C*04:145")
    assert result.__class__ is Allele, f'Expected parse("C*04:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_146():
    result = parse("C*04:146")
    assert result.__class__ is Allele, f'Expected parse("C*04:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_147():
    result = parse("C*04:147")
    assert result.__class__ is Allele, f'Expected parse("C*04:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_148():
    result = parse("C*04:148")
    assert result.__class__ is Allele, f'Expected parse("C*04:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_149():
    result = parse("C*04:149")
    assert result.__class__ is Allele, f'Expected parse("C*04:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_150():
    result = parse("C*04:150")
    assert result.__class__ is Allele, f'Expected parse("C*04:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_151():
    result = parse("C*04:151")
    assert result.__class__ is Allele, f'Expected parse("C*04:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_152():
    result = parse("C*04:152")
    assert result.__class__ is Allele, f'Expected parse("C*04:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_153():
    result = parse("C*04:153")
    assert result.__class__ is Allele, f'Expected parse("C*04:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_154():
    result = parse("C*04:154")
    assert result.__class__ is Allele, f'Expected parse("C*04:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_155():
    result = parse("C*04:155")
    assert result.__class__ is Allele, f'Expected parse("C*04:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_156():
    result = parse("C*04:156")
    assert result.__class__ is Allele, f'Expected parse("C*04:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_157():
    result = parse("C*04:157")
    assert result.__class__ is Allele, f'Expected parse("C*04:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_158():
    result = parse("C*04:158")
    assert result.__class__ is Allele, f'Expected parse("C*04:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_159():
    result = parse("C*04:159")
    assert result.__class__ is Allele, f'Expected parse("C*04:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_15_01():
    result = parse("C*04:15:01")
    assert result.__class__ is Allele, f'Expected parse("C*04:15:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:15:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_15_02():
    result = parse("C*04:15:02")
    assert result.__class__ is Allele, f'Expected parse("C*04:15:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:15:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_15_03():
    result = parse("C*04:15:03")
    assert result.__class__ is Allele, f'Expected parse("C*04:15:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:15:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_16():
    result = parse("C*04:16")
    assert result.__class__ is Allele, f'Expected parse("C*04:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_160():
    result = parse("C*04:160")
    assert result.__class__ is Allele, f'Expected parse("C*04:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_161():
    result = parse("C*04:161")
    assert result.__class__ is Allele, f'Expected parse("C*04:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_162():
    result = parse("C*04:162")
    assert result.__class__ is Allele, f'Expected parse("C*04:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_163():
    result = parse("C*04:163")
    assert result.__class__ is Allele, f'Expected parse("C*04:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_164_01():
    result = parse("C*04:164:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:164:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:164:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_164_02():
    result = parse("C*04:164:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:164:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:164:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_165():
    result = parse("C*04:165")
    assert result.__class__ is Allele, f'Expected parse("C*04:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_166_01():
    result = parse("C*04:166:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:166:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:166:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_166_02():
    result = parse("C*04:166:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:166:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:166:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_167():
    result = parse("C*04:167")
    assert result.__class__ is Allele, f'Expected parse("C*04:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_168():
    result = parse("C*04:168")
    assert result.__class__ is Allele, f'Expected parse("C*04:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_169():
    result = parse("C*04:169")
    assert result.__class__ is Allele, f'Expected parse("C*04:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_17():
    result = parse("C*04:17")
    assert result.__class__ is Allele, f'Expected parse("C*04:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_170N():
    result = parse("C*04:170N")
    assert result.__class__ is Allele, f'Expected parse("C*04:170N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:170N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_171():
    result = parse("C*04:171")
    assert result.__class__ is Allele, f'Expected parse("C*04:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_172():
    result = parse("C*04:172")
    assert result.__class__ is Allele, f'Expected parse("C*04:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_173N():
    result = parse("C*04:173N")
    assert result.__class__ is Allele, f'Expected parse("C*04:173N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:173N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_174():
    result = parse("C*04:174")
    assert result.__class__ is Allele, f'Expected parse("C*04:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_175():
    result = parse("C*04:175")
    assert result.__class__ is Allele, f'Expected parse("C*04:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_176():
    result = parse("C*04:176")
    assert result.__class__ is Allele, f'Expected parse("C*04:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_177():
    result = parse("C*04:177")
    assert result.__class__ is Allele, f'Expected parse("C*04:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_178():
    result = parse("C*04:178")
    assert result.__class__ is Allele, f'Expected parse("C*04:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_179():
    result = parse("C*04:179")
    assert result.__class__ is Allele, f'Expected parse("C*04:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_18():
    result = parse("C*04:18")
    assert result.__class__ is Allele, f'Expected parse("C*04:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_180_01():
    result = parse("C*04:180:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:180:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:180:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_180_02():
    result = parse("C*04:180:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:180:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:180:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_181():
    result = parse("C*04:181")
    assert result.__class__ is Allele, f'Expected parse("C*04:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_182():
    result = parse("C*04:182")
    assert result.__class__ is Allele, f'Expected parse("C*04:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_183():
    result = parse("C*04:183")
    assert result.__class__ is Allele, f'Expected parse("C*04:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_184():
    result = parse("C*04:184")
    assert result.__class__ is Allele, f'Expected parse("C*04:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_185():
    result = parse("C*04:185")
    assert result.__class__ is Allele, f'Expected parse("C*04:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_186():
    result = parse("C*04:186")
    assert result.__class__ is Allele, f'Expected parse("C*04:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_187():
    result = parse("C*04:187")
    assert result.__class__ is Allele, f'Expected parse("C*04:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_188():
    result = parse("C*04:188")
    assert result.__class__ is Allele, f'Expected parse("C*04:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_189():
    result = parse("C*04:189")
    assert result.__class__ is Allele, f'Expected parse("C*04:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_19():
    result = parse("C*04:19")
    assert result.__class__ is Allele, f'Expected parse("C*04:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_190():
    result = parse("C*04:190")
    assert result.__class__ is Allele, f'Expected parse("C*04:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_191N():
    result = parse("C*04:191N")
    assert result.__class__ is Allele, f'Expected parse("C*04:191N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:191N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_192():
    result = parse("C*04:192")
    assert result.__class__ is Allele, f'Expected parse("C*04:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_193():
    result = parse("C*04:193")
    assert result.__class__ is Allele, f'Expected parse("C*04:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_194():
    result = parse("C*04:194")
    assert result.__class__ is Allele, f'Expected parse("C*04:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_195():
    result = parse("C*04:195")
    assert result.__class__ is Allele, f'Expected parse("C*04:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_196():
    result = parse("C*04:196")
    assert result.__class__ is Allele, f'Expected parse("C*04:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_197():
    result = parse("C*04:197")
    assert result.__class__ is Allele, f'Expected parse("C*04:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_198():
    result = parse("C*04:198")
    assert result.__class__ is Allele, f'Expected parse("C*04:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_199():
    result = parse("C*04:199")
    assert result.__class__ is Allele, f'Expected parse("C*04:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_20():
    result = parse("C*04:20")
    assert result.__class__ is Allele, f'Expected parse("C*04:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_200():
    result = parse("C*04:200")
    assert result.__class__ is Allele, f'Expected parse("C*04:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_201_01():
    result = parse("C*04:201:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:201:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:201:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_201_02():
    result = parse("C*04:201:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:201:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:201:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_202():
    result = parse("C*04:202")
    assert result.__class__ is Allele, f'Expected parse("C*04:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_203N():
    result = parse("C*04:203N")
    assert result.__class__ is Allele, f'Expected parse("C*04:203N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:203N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_204():
    result = parse("C*04:204")
    assert result.__class__ is Allele, f'Expected parse("C*04:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_205N():
    result = parse("C*04:205N")
    assert result.__class__ is Allele, f'Expected parse("C*04:205N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:205N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_206():
    result = parse("C*04:206")
    assert result.__class__ is Allele, f'Expected parse("C*04:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_207():
    result = parse("C*04:207")
    assert result.__class__ is Allele, f'Expected parse("C*04:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_208():
    result = parse("C*04:208")
    assert result.__class__ is Allele, f'Expected parse("C*04:208") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_209():
    result = parse("C*04:209")
    assert result.__class__ is Allele, f'Expected parse("C*04:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_210():
    result = parse("C*04:210")
    assert result.__class__ is Allele, f'Expected parse("C*04:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_211():
    result = parse("C*04:211")
    assert result.__class__ is Allele, f'Expected parse("C*04:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_212():
    result = parse("C*04:212")
    assert result.__class__ is Allele, f'Expected parse("C*04:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_213():
    result = parse("C*04:213")
    assert result.__class__ is Allele, f'Expected parse("C*04:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_214():
    result = parse("C*04:214")
    assert result.__class__ is Allele, f'Expected parse("C*04:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_215N():
    result = parse("C*04:215N")
    assert result.__class__ is Allele, f'Expected parse("C*04:215N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:215N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_216():
    result = parse("C*04:216")
    assert result.__class__ is Allele, f'Expected parse("C*04:216") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_217N():
    result = parse("C*04:217N")
    assert result.__class__ is Allele, f'Expected parse("C*04:217N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:217N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_218():
    result = parse("C*04:218")
    assert result.__class__ is Allele, f'Expected parse("C*04:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_219():
    result = parse("C*04:219")
    assert result.__class__ is Allele, f'Expected parse("C*04:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_220():
    result = parse("C*04:220")
    assert result.__class__ is Allele, f'Expected parse("C*04:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_221():
    result = parse("C*04:221")
    assert result.__class__ is Allele, f'Expected parse("C*04:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_222():
    result = parse("C*04:222")
    assert result.__class__ is Allele, f'Expected parse("C*04:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_223_01():
    result = parse("C*04:223:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:223:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:223:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_223_02():
    result = parse("C*04:223:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:223:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:223:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_224():
    result = parse("C*04:224")
    assert result.__class__ is Allele, f'Expected parse("C*04:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_225N():
    result = parse("C*04:225N")
    assert result.__class__ is Allele, f'Expected parse("C*04:225N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:225N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_226():
    result = parse("C*04:226")
    assert result.__class__ is Allele, f'Expected parse("C*04:226") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_227():
    result = parse("C*04:227")
    assert result.__class__ is Allele, f'Expected parse("C*04:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_228():
    result = parse("C*04:228")
    assert result.__class__ is Allele, f'Expected parse("C*04:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_229():
    result = parse("C*04:229")
    assert result.__class__ is Allele, f'Expected parse("C*04:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_23():
    result = parse("C*04:23")
    assert result.__class__ is Allele, f'Expected parse("C*04:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_230():
    result = parse("C*04:230")
    assert result.__class__ is Allele, f'Expected parse("C*04:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_231():
    result = parse("C*04:231")
    assert result.__class__ is Allele, f'Expected parse("C*04:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_232():
    result = parse("C*04:232")
    assert result.__class__ is Allele, f'Expected parse("C*04:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_233N():
    result = parse("C*04:233N")
    assert result.__class__ is Allele, f'Expected parse("C*04:233N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:233N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_234N():
    result = parse("C*04:234N")
    assert result.__class__ is Allele, f'Expected parse("C*04:234N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:234N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_235():
    result = parse("C*04:235")
    assert result.__class__ is Allele, f'Expected parse("C*04:235") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_236N():
    result = parse("C*04:236N")
    assert result.__class__ is Allele, f'Expected parse("C*04:236N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:236N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_237():
    result = parse("C*04:237")
    assert result.__class__ is Allele, f'Expected parse("C*04:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_238():
    result = parse("C*04:238")
    assert result.__class__ is Allele, f'Expected parse("C*04:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_239():
    result = parse("C*04:239")
    assert result.__class__ is Allele, f'Expected parse("C*04:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_24():
    result = parse("C*04:24")
    assert result.__class__ is Allele, f'Expected parse("C*04:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_240():
    result = parse("C*04:240")
    assert result.__class__ is Allele, f'Expected parse("C*04:240") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_241():
    result = parse("C*04:241")
    assert result.__class__ is Allele, f'Expected parse("C*04:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_242():
    result = parse("C*04:242")
    assert result.__class__ is Allele, f'Expected parse("C*04:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_243():
    result = parse("C*04:243")
    assert result.__class__ is Allele, f'Expected parse("C*04:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_244():
    result = parse("C*04:244")
    assert result.__class__ is Allele, f'Expected parse("C*04:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_245():
    result = parse("C*04:245")
    assert result.__class__ is Allele, f'Expected parse("C*04:245") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_246():
    result = parse("C*04:246")
    assert result.__class__ is Allele, f'Expected parse("C*04:246") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_247():
    result = parse("C*04:247")
    assert result.__class__ is Allele, f'Expected parse("C*04:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_248():
    result = parse("C*04:248")
    assert result.__class__ is Allele, f'Expected parse("C*04:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_249():
    result = parse("C*04:249")
    assert result.__class__ is Allele, f'Expected parse("C*04:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_25():
    result = parse("C*04:25")
    assert result.__class__ is Allele, f'Expected parse("C*04:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_250():
    result = parse("C*04:250")
    assert result.__class__ is Allele, f'Expected parse("C*04:250") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_251():
    result = parse("C*04:251")
    assert result.__class__ is Allele, f'Expected parse("C*04:251") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_252():
    result = parse("C*04:252")
    assert result.__class__ is Allele, f'Expected parse("C*04:252") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_253N():
    result = parse("C*04:253N")
    assert result.__class__ is Allele, f'Expected parse("C*04:253N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:253N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_254():
    result = parse("C*04:254")
    assert result.__class__ is Allele, f'Expected parse("C*04:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_255N():
    result = parse("C*04:255N")
    assert result.__class__ is Allele, f'Expected parse("C*04:255N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:255N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_256():
    result = parse("C*04:256")
    assert result.__class__ is Allele, f'Expected parse("C*04:256") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_257():
    result = parse("C*04:257")
    assert result.__class__ is Allele, f'Expected parse("C*04:257") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_258():
    result = parse("C*04:258")
    assert result.__class__ is Allele, f'Expected parse("C*04:258") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_259():
    result = parse("C*04:259")
    assert result.__class__ is Allele, f'Expected parse("C*04:259") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_26():
    result = parse("C*04:26")
    assert result.__class__ is Allele, f'Expected parse("C*04:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_260():
    result = parse("C*04:260")
    assert result.__class__ is Allele, f'Expected parse("C*04:260") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_261():
    result = parse("C*04:261")
    assert result.__class__ is Allele, f'Expected parse("C*04:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_262():
    result = parse("C*04:262")
    assert result.__class__ is Allele, f'Expected parse("C*04:262") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_263():
    result = parse("C*04:263")
    assert result.__class__ is Allele, f'Expected parse("C*04:263") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_264():
    result = parse("C*04:264")
    assert result.__class__ is Allele, f'Expected parse("C*04:264") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_265():
    result = parse("C*04:265")
    assert result.__class__ is Allele, f'Expected parse("C*04:265") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_266():
    result = parse("C*04:266")
    assert result.__class__ is Allele, f'Expected parse("C*04:266") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_267():
    result = parse("C*04:267")
    assert result.__class__ is Allele, f'Expected parse("C*04:267") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_268():
    result = parse("C*04:268")
    assert result.__class__ is Allele, f'Expected parse("C*04:268") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_269():
    result = parse("C*04:269")
    assert result.__class__ is Allele, f'Expected parse("C*04:269") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_27():
    result = parse("C*04:27")
    assert result.__class__ is Allele, f'Expected parse("C*04:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_270():
    result = parse("C*04:270")
    assert result.__class__ is Allele, f'Expected parse("C*04:270") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_271():
    result = parse("C*04:271")
    assert result.__class__ is Allele, f'Expected parse("C*04:271") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_272():
    result = parse("C*04:272")
    assert result.__class__ is Allele, f'Expected parse("C*04:272") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_273():
    result = parse("C*04:273")
    assert result.__class__ is Allele, f'Expected parse("C*04:273") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_274():
    result = parse("C*04:274")
    assert result.__class__ is Allele, f'Expected parse("C*04:274") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_275():
    result = parse("C*04:275")
    assert result.__class__ is Allele, f'Expected parse("C*04:275") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_276():
    result = parse("C*04:276")
    assert result.__class__ is Allele, f'Expected parse("C*04:276") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_277():
    result = parse("C*04:277")
    assert result.__class__ is Allele, f'Expected parse("C*04:277") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_278():
    result = parse("C*04:278")
    assert result.__class__ is Allele, f'Expected parse("C*04:278") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_279N():
    result = parse("C*04:279N")
    assert result.__class__ is Allele, f'Expected parse("C*04:279N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:279N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_28():
    result = parse("C*04:28")
    assert result.__class__ is Allele, f'Expected parse("C*04:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_280():
    result = parse("C*04:280")
    assert result.__class__ is Allele, f'Expected parse("C*04:280") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_281():
    result = parse("C*04:281")
    assert result.__class__ is Allele, f'Expected parse("C*04:281") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_282():
    result = parse("C*04:282")
    assert result.__class__ is Allele, f'Expected parse("C*04:282") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_283():
    result = parse("C*04:283")
    assert result.__class__ is Allele, f'Expected parse("C*04:283") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_284():
    result = parse("C*04:284")
    assert result.__class__ is Allele, f'Expected parse("C*04:284") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_285():
    result = parse("C*04:285")
    assert result.__class__ is Allele, f'Expected parse("C*04:285") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_286():
    result = parse("C*04:286")
    assert result.__class__ is Allele, f'Expected parse("C*04:286") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_287():
    result = parse("C*04:287")
    assert result.__class__ is Allele, f'Expected parse("C*04:287") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:287") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_288():
    result = parse("C*04:288")
    assert result.__class__ is Allele, f'Expected parse("C*04:288") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_289():
    result = parse("C*04:289")
    assert result.__class__ is Allele, f'Expected parse("C*04:289") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_29():
    result = parse("C*04:29")
    assert result.__class__ is Allele, f'Expected parse("C*04:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_290():
    result = parse("C*04:290")
    assert result.__class__ is Allele, f'Expected parse("C*04:290") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_291():
    result = parse("C*04:291")
    assert result.__class__ is Allele, f'Expected parse("C*04:291") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_292():
    result = parse("C*04:292")
    assert result.__class__ is Allele, f'Expected parse("C*04:292") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_293():
    result = parse("C*04:293")
    assert result.__class__ is Allele, f'Expected parse("C*04:293") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_294():
    result = parse("C*04:294")
    assert result.__class__ is Allele, f'Expected parse("C*04:294") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_295():
    result = parse("C*04:295")
    assert result.__class__ is Allele, f'Expected parse("C*04:295") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_296():
    result = parse("C*04:296")
    assert result.__class__ is Allele, f'Expected parse("C*04:296") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_297():
    result = parse("C*04:297")
    assert result.__class__ is Allele, f'Expected parse("C*04:297") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_298():
    result = parse("C*04:298")
    assert result.__class__ is Allele, f'Expected parse("C*04:298") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_299():
    result = parse("C*04:299")
    assert result.__class__ is Allele, f'Expected parse("C*04:299") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_30():
    result = parse("C*04:30")
    assert result.__class__ is Allele, f'Expected parse("C*04:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_300N():
    result = parse("C*04:300N")
    assert result.__class__ is Allele, f'Expected parse("C*04:300N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:300N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_301():
    result = parse("C*04:301")
    assert result.__class__ is Allele, f'Expected parse("C*04:301") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_302():
    result = parse("C*04:302")
    assert result.__class__ is Allele, f'Expected parse("C*04:302") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_303():
    result = parse("C*04:303")
    assert result.__class__ is Allele, f'Expected parse("C*04:303") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:303") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_304_01():
    result = parse("C*04:304:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:304:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:304:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_304_02():
    result = parse("C*04:304:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:304:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:304:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_305N():
    result = parse("C*04:305N")
    assert result.__class__ is Allele, f'Expected parse("C*04:305N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:305N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_306():
    result = parse("C*04:306")
    assert result.__class__ is Allele, f'Expected parse("C*04:306") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:306") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_307():
    result = parse("C*04:307")
    assert result.__class__ is Allele, f'Expected parse("C*04:307") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_308():
    result = parse("C*04:308")
    assert result.__class__ is Allele, f'Expected parse("C*04:308") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:308") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_309N():
    result = parse("C*04:309N")
    assert result.__class__ is Allele, f'Expected parse("C*04:309N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:309N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_31():
    result = parse("C*04:31")
    assert result.__class__ is Allele, f'Expected parse("C*04:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_310():
    result = parse("C*04:310")
    assert result.__class__ is Allele, f'Expected parse("C*04:310") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:310") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_311():
    result = parse("C*04:311")
    assert result.__class__ is Allele, f'Expected parse("C*04:311") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:311") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_312():
    result = parse("C*04:312")
    assert result.__class__ is Allele, f'Expected parse("C*04:312") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:312") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_313_01_01():
    result = parse("C*04:313:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:313:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:313:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_313_01_02():
    result = parse("C*04:313:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:313:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:313:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_314():
    result = parse("C*04:314")
    assert result.__class__ is Allele, f'Expected parse("C*04:314") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:314") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_315():
    result = parse("C*04:315")
    assert result.__class__ is Allele, f'Expected parse("C*04:315") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:315") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_316():
    result = parse("C*04:316")
    assert result.__class__ is Allele, f'Expected parse("C*04:316") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:316") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_317():
    result = parse("C*04:317")
    assert result.__class__ is Allele, f'Expected parse("C*04:317") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:317") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_318():
    result = parse("C*04:318")
    assert result.__class__ is Allele, f'Expected parse("C*04:318") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:318") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_319():
    result = parse("C*04:319")
    assert result.__class__ is Allele, f'Expected parse("C*04:319") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_32():
    result = parse("C*04:32")
    assert result.__class__ is Allele, f'Expected parse("C*04:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_320():
    result = parse("C*04:320")
    assert result.__class__ is Allele, f'Expected parse("C*04:320") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:320") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_321():
    result = parse("C*04:321")
    assert result.__class__ is Allele, f'Expected parse("C*04:321") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:321") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_322():
    result = parse("C*04:322")
    assert result.__class__ is Allele, f'Expected parse("C*04:322") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:322") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_323():
    result = parse("C*04:323")
    assert result.__class__ is Allele, f'Expected parse("C*04:323") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:323") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_324():
    result = parse("C*04:324")
    assert result.__class__ is Allele, f'Expected parse("C*04:324") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:324") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_325():
    result = parse("C*04:325")
    assert result.__class__ is Allele, f'Expected parse("C*04:325") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:325") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_326():
    result = parse("C*04:326")
    assert result.__class__ is Allele, f'Expected parse("C*04:326") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:326") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_327():
    result = parse("C*04:327")
    assert result.__class__ is Allele, f'Expected parse("C*04:327") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:327") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_328_01():
    result = parse("C*04:328:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:328:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:328:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_328_02():
    result = parse("C*04:328:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:328:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:328:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_329():
    result = parse("C*04:329")
    assert result.__class__ is Allele, f'Expected parse("C*04:329") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:329") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_33():
    result = parse("C*04:33")
    assert result.__class__ is Allele, f'Expected parse("C*04:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_330():
    result = parse("C*04:330")
    assert result.__class__ is Allele, f'Expected parse("C*04:330") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:330") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_331():
    result = parse("C*04:331")
    assert result.__class__ is Allele, f'Expected parse("C*04:331") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:331") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_332():
    result = parse("C*04:332")
    assert result.__class__ is Allele, f'Expected parse("C*04:332") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:332") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_333():
    result = parse("C*04:333")
    assert result.__class__ is Allele, f'Expected parse("C*04:333") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:333") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_334():
    result = parse("C*04:334")
    assert result.__class__ is Allele, f'Expected parse("C*04:334") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:334") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_335():
    result = parse("C*04:335")
    assert result.__class__ is Allele, f'Expected parse("C*04:335") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:335") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_336():
    result = parse("C*04:336")
    assert result.__class__ is Allele, f'Expected parse("C*04:336") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:336") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_337():
    result = parse("C*04:337")
    assert result.__class__ is Allele, f'Expected parse("C*04:337") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:337") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_338Q():
    result = parse("C*04:338Q")
    assert result.__class__ is Allele, f'Expected parse("C*04:338Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:338Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_339_01():
    result = parse("C*04:339:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:339:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:339:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_339_02():
    result = parse("C*04:339:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:339:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:339:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_34():
    result = parse("C*04:34")
    assert result.__class__ is Allele, f'Expected parse("C*04:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_340():
    result = parse("C*04:340")
    assert result.__class__ is Allele, f'Expected parse("C*04:340") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:340") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_341():
    result = parse("C*04:341")
    assert result.__class__ is Allele, f'Expected parse("C*04:341") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:341") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_342():
    result = parse("C*04:342")
    assert result.__class__ is Allele, f'Expected parse("C*04:342") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:342") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_343():
    result = parse("C*04:343")
    assert result.__class__ is Allele, f'Expected parse("C*04:343") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:343") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_344():
    result = parse("C*04:344")
    assert result.__class__ is Allele, f'Expected parse("C*04:344") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:344") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_345():
    result = parse("C*04:345")
    assert result.__class__ is Allele, f'Expected parse("C*04:345") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:345") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_346():
    result = parse("C*04:346")
    assert result.__class__ is Allele, f'Expected parse("C*04:346") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:346") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_347():
    result = parse("C*04:347")
    assert result.__class__ is Allele, f'Expected parse("C*04:347") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:347") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_348():
    result = parse("C*04:348")
    assert result.__class__ is Allele, f'Expected parse("C*04:348") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:348") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_349N():
    result = parse("C*04:349N")
    assert result.__class__ is Allele, f'Expected parse("C*04:349N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:349N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_350N():
    result = parse("C*04:350N")
    assert result.__class__ is Allele, f'Expected parse("C*04:350N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:350N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_351_01():
    result = parse("C*04:351:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:351:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:351:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_351_02():
    result = parse("C*04:351:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:351:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:351:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_352():
    result = parse("C*04:352")
    assert result.__class__ is Allele, f'Expected parse("C*04:352") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:352") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_353():
    result = parse("C*04:353")
    assert result.__class__ is Allele, f'Expected parse("C*04:353") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:353") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_354():
    result = parse("C*04:354")
    assert result.__class__ is Allele, f'Expected parse("C*04:354") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:354") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_355():
    result = parse("C*04:355")
    assert result.__class__ is Allele, f'Expected parse("C*04:355") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:355") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_356():
    result = parse("C*04:356")
    assert result.__class__ is Allele, f'Expected parse("C*04:356") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:356") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_357():
    result = parse("C*04:357")
    assert result.__class__ is Allele, f'Expected parse("C*04:357") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:357") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_358():
    result = parse("C*04:358")
    assert result.__class__ is Allele, f'Expected parse("C*04:358") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:358") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_359():
    result = parse("C*04:359")
    assert result.__class__ is Allele, f'Expected parse("C*04:359") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:359") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_35_01():
    result = parse("C*04:35:01")
    assert result.__class__ is Allele, f'Expected parse("C*04:35:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:35:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_35_02():
    result = parse("C*04:35:02")
    assert result.__class__ is Allele, f'Expected parse("C*04:35:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:35:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_36():
    result = parse("C*04:36")
    assert result.__class__ is Allele, f'Expected parse("C*04:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_360():
    result = parse("C*04:360")
    assert result.__class__ is Allele, f'Expected parse("C*04:360") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:360") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_361():
    result = parse("C*04:361")
    assert result.__class__ is Allele, f'Expected parse("C*04:361") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:361") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_362N():
    result = parse("C*04:362N")
    assert result.__class__ is Allele, f'Expected parse("C*04:362N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:362N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_363():
    result = parse("C*04:363")
    assert result.__class__ is Allele, f'Expected parse("C*04:363") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:363") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_364N():
    result = parse("C*04:364N")
    assert result.__class__ is Allele, f'Expected parse("C*04:364N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:364N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_365N():
    result = parse("C*04:365N")
    assert result.__class__ is Allele, f'Expected parse("C*04:365N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:365N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_366():
    result = parse("C*04:366")
    assert result.__class__ is Allele, f'Expected parse("C*04:366") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:366") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_367():
    result = parse("C*04:367")
    assert result.__class__ is Allele, f'Expected parse("C*04:367") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:367") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_368():
    result = parse("C*04:368")
    assert result.__class__ is Allele, f'Expected parse("C*04:368") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:368") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_369N():
    result = parse("C*04:369N")
    assert result.__class__ is Allele, f'Expected parse("C*04:369N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:369N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_37():
    result = parse("C*04:37")
    assert result.__class__ is Allele, f'Expected parse("C*04:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_370():
    result = parse("C*04:370")
    assert result.__class__ is Allele, f'Expected parse("C*04:370") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:370") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_371N():
    result = parse("C*04:371N")
    assert result.__class__ is Allele, f'Expected parse("C*04:371N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:371N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_372():
    result = parse("C*04:372")
    assert result.__class__ is Allele, f'Expected parse("C*04:372") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:372") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_373():
    result = parse("C*04:373")
    assert result.__class__ is Allele, f'Expected parse("C*04:373") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:373") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_374N():
    result = parse("C*04:374N")
    assert result.__class__ is Allele, f'Expected parse("C*04:374N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:374N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_375():
    result = parse("C*04:375")
    assert result.__class__ is Allele, f'Expected parse("C*04:375") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:375") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_376():
    result = parse("C*04:376")
    assert result.__class__ is Allele, f'Expected parse("C*04:376") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:376") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_377N():
    result = parse("C*04:377N")
    assert result.__class__ is Allele, f'Expected parse("C*04:377N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:377N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_378():
    result = parse("C*04:378")
    assert result.__class__ is Allele, f'Expected parse("C*04:378") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:378") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_379():
    result = parse("C*04:379")
    assert result.__class__ is Allele, f'Expected parse("C*04:379") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:379") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_38():
    result = parse("C*04:38")
    assert result.__class__ is Allele, f'Expected parse("C*04:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_380():
    result = parse("C*04:380")
    assert result.__class__ is Allele, f'Expected parse("C*04:380") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:380") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_381():
    result = parse("C*04:381")
    assert result.__class__ is Allele, f'Expected parse("C*04:381") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:381") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_382Q():
    result = parse("C*04:382Q")
    assert result.__class__ is Allele, f'Expected parse("C*04:382Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:382Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_383():
    result = parse("C*04:383")
    assert result.__class__ is Allele, f'Expected parse("C*04:383") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:383") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_384():
    result = parse("C*04:384")
    assert result.__class__ is Allele, f'Expected parse("C*04:384") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:384") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_385N():
    result = parse("C*04:385N")
    assert result.__class__ is Allele, f'Expected parse("C*04:385N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:385N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_386():
    result = parse("C*04:386")
    assert result.__class__ is Allele, f'Expected parse("C*04:386") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:386") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_387():
    result = parse("C*04:387")
    assert result.__class__ is Allele, f'Expected parse("C*04:387") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:387") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_388():
    result = parse("C*04:388")
    assert result.__class__ is Allele, f'Expected parse("C*04:388") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:388") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_389():
    result = parse("C*04:389")
    assert result.__class__ is Allele, f'Expected parse("C*04:389") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:389") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_39():
    result = parse("C*04:39")
    assert result.__class__ is Allele, f'Expected parse("C*04:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_390():
    result = parse("C*04:390")
    assert result.__class__ is Allele, f'Expected parse("C*04:390") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:390") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_391():
    result = parse("C*04:391")
    assert result.__class__ is Allele, f'Expected parse("C*04:391") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:391") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_392():
    result = parse("C*04:392")
    assert result.__class__ is Allele, f'Expected parse("C*04:392") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:392") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_393():
    result = parse("C*04:393")
    assert result.__class__ is Allele, f'Expected parse("C*04:393") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:393") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_394():
    result = parse("C*04:394")
    assert result.__class__ is Allele, f'Expected parse("C*04:394") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:394") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_395():
    result = parse("C*04:395")
    assert result.__class__ is Allele, f'Expected parse("C*04:395") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:395") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_396N():
    result = parse("C*04:396N")
    assert result.__class__ is Allele, f'Expected parse("C*04:396N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:396N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_397():
    result = parse("C*04:397")
    assert result.__class__ is Allele, f'Expected parse("C*04:397") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:397") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_398():
    result = parse("C*04:398")
    assert result.__class__ is Allele, f'Expected parse("C*04:398") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:398") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_399():
    result = parse("C*04:399")
    assert result.__class__ is Allele, f'Expected parse("C*04:399") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:399") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_40():
    result = parse("C*04:40")
    assert result.__class__ is Allele, f'Expected parse("C*04:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_400():
    result = parse("C*04:400")
    assert result.__class__ is Allele, f'Expected parse("C*04:400") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:400") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_401():
    result = parse("C*04:401")
    assert result.__class__ is Allele, f'Expected parse("C*04:401") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:401") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_402():
    result = parse("C*04:402")
    assert result.__class__ is Allele, f'Expected parse("C*04:402") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:402") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_403():
    result = parse("C*04:403")
    assert result.__class__ is Allele, f'Expected parse("C*04:403") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:403") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_404():
    result = parse("C*04:404")
    assert result.__class__ is Allele, f'Expected parse("C*04:404") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:404") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_405():
    result = parse("C*04:405")
    assert result.__class__ is Allele, f'Expected parse("C*04:405") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:405") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_406():
    result = parse("C*04:406")
    assert result.__class__ is Allele, f'Expected parse("C*04:406") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:406") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_407():
    result = parse("C*04:407")
    assert result.__class__ is Allele, f'Expected parse("C*04:407") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:407") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_408():
    result = parse("C*04:408")
    assert result.__class__ is Allele, f'Expected parse("C*04:408") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:408") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_409():
    result = parse("C*04:409")
    assert result.__class__ is Allele, f'Expected parse("C*04:409") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:409") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_41():
    result = parse("C*04:41")
    assert result.__class__ is Allele, f'Expected parse("C*04:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_410N():
    result = parse("C*04:410N")
    assert result.__class__ is Allele, f'Expected parse("C*04:410N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:410N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_411N():
    result = parse("C*04:411N")
    assert result.__class__ is Allele, f'Expected parse("C*04:411N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:411N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_412():
    result = parse("C*04:412")
    assert result.__class__ is Allele, f'Expected parse("C*04:412") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:412") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_413():
    result = parse("C*04:413")
    assert result.__class__ is Allele, f'Expected parse("C*04:413") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:413") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_414():
    result = parse("C*04:414")
    assert result.__class__ is Allele, f'Expected parse("C*04:414") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:414") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_415():
    result = parse("C*04:415")
    assert result.__class__ is Allele, f'Expected parse("C*04:415") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:415") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_416():
    result = parse("C*04:416")
    assert result.__class__ is Allele, f'Expected parse("C*04:416") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:416") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_417N():
    result = parse("C*04:417N")
    assert result.__class__ is Allele, f'Expected parse("C*04:417N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:417N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_418():
    result = parse("C*04:418")
    assert result.__class__ is Allele, f'Expected parse("C*04:418") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:418") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_419():
    result = parse("C*04:419")
    assert result.__class__ is Allele, f'Expected parse("C*04:419") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:419") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_420():
    result = parse("C*04:420")
    assert result.__class__ is Allele, f'Expected parse("C*04:420") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:420") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_421():
    result = parse("C*04:421")
    assert result.__class__ is Allele, f'Expected parse("C*04:421") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:421") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_422():
    result = parse("C*04:422")
    assert result.__class__ is Allele, f'Expected parse("C*04:422") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:422") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_423():
    result = parse("C*04:423")
    assert result.__class__ is Allele, f'Expected parse("C*04:423") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:423") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_424():
    result = parse("C*04:424")
    assert result.__class__ is Allele, f'Expected parse("C*04:424") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:424") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_42_01():
    result = parse("C*04:42:01")
    assert result.__class__ is Allele, f'Expected parse("C*04:42:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:42:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_42_02():
    result = parse("C*04:42:02")
    assert result.__class__ is Allele, f'Expected parse("C*04:42:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:42:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_43():
    result = parse("C*04:43")
    assert result.__class__ is Allele, f'Expected parse("C*04:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_44():
    result = parse("C*04:44")
    assert result.__class__ is Allele, f'Expected parse("C*04:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_45():
    result = parse("C*04:45")
    assert result.__class__ is Allele, f'Expected parse("C*04:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_46():
    result = parse("C*04:46")
    assert result.__class__ is Allele, f'Expected parse("C*04:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_47():
    result = parse("C*04:47")
    assert result.__class__ is Allele, f'Expected parse("C*04:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_48():
    result = parse("C*04:48")
    assert result.__class__ is Allele, f'Expected parse("C*04:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_49():
    result = parse("C*04:49")
    assert result.__class__ is Allele, f'Expected parse("C*04:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_50():
    result = parse("C*04:50")
    assert result.__class__ is Allele, f'Expected parse("C*04:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_51():
    result = parse("C*04:51")
    assert result.__class__ is Allele, f'Expected parse("C*04:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_52():
    result = parse("C*04:52")
    assert result.__class__ is Allele, f'Expected parse("C*04:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_53():
    result = parse("C*04:53")
    assert result.__class__ is Allele, f'Expected parse("C*04:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_54_01():
    result = parse("C*04:54:01")
    assert result.__class__ is Allele, f'Expected parse("C*04:54:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:54:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_54_02():
    result = parse("C*04:54:02")
    assert result.__class__ is Allele, f'Expected parse("C*04:54:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:54:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_55():
    result = parse("C*04:55")
    assert result.__class__ is Allele, f'Expected parse("C*04:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_56():
    result = parse("C*04:56")
    assert result.__class__ is Allele, f'Expected parse("C*04:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_57():
    result = parse("C*04:57")
    assert result.__class__ is Allele, f'Expected parse("C*04:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_58():
    result = parse("C*04:58")
    assert result.__class__ is Allele, f'Expected parse("C*04:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_59Q():
    result = parse("C*04:59Q")
    assert result.__class__ is Allele, f'Expected parse("C*04:59Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:59Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_60():
    result = parse("C*04:60")
    assert result.__class__ is Allele, f'Expected parse("C*04:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_61():
    result = parse("C*04:61")
    assert result.__class__ is Allele, f'Expected parse("C*04:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_62():
    result = parse("C*04:62")
    assert result.__class__ is Allele, f'Expected parse("C*04:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_63():
    result = parse("C*04:63")
    assert result.__class__ is Allele, f'Expected parse("C*04:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_64_01():
    result = parse("C*04:64:01")
    assert result.__class__ is Allele, f'Expected parse("C*04:64:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:64:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_64_02():
    result = parse("C*04:64:02")
    assert result.__class__ is Allele, f'Expected parse("C*04:64:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:64:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_65_01_01():
    result = parse("C*04:65:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:65:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:65:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_65_01_02():
    result = parse("C*04:65:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*04:65:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*04:65:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_66():
    result = parse("C*04:66")
    assert result.__class__ is Allele, f'Expected parse("C*04:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_67():
    result = parse("C*04:67")
    assert result.__class__ is Allele, f'Expected parse("C*04:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_68():
    result = parse("C*04:68")
    assert result.__class__ is Allele, f'Expected parse("C*04:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_69():
    result = parse("C*04:69")
    assert result.__class__ is Allele, f'Expected parse("C*04:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_70():
    result = parse("C*04:70")
    assert result.__class__ is Allele, f'Expected parse("C*04:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_71():
    result = parse("C*04:71")
    assert result.__class__ is Allele, f'Expected parse("C*04:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_72():
    result = parse("C*04:72")
    assert result.__class__ is Allele, f'Expected parse("C*04:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_73():
    result = parse("C*04:73")
    assert result.__class__ is Allele, f'Expected parse("C*04:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_74():
    result = parse("C*04:74")
    assert result.__class__ is Allele, f'Expected parse("C*04:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_75():
    result = parse("C*04:75")
    assert result.__class__ is Allele, f'Expected parse("C*04:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_76():
    result = parse("C*04:76")
    assert result.__class__ is Allele, f'Expected parse("C*04:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_77():
    result = parse("C*04:77")
    assert result.__class__ is Allele, f'Expected parse("C*04:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_78():
    result = parse("C*04:78")
    assert result.__class__ is Allele, f'Expected parse("C*04:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_79():
    result = parse("C*04:79")
    assert result.__class__ is Allele, f'Expected parse("C*04:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_80():
    result = parse("C*04:80")
    assert result.__class__ is Allele, f'Expected parse("C*04:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_81():
    result = parse("C*04:81")
    assert result.__class__ is Allele, f'Expected parse("C*04:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_82():
    result = parse("C*04:82")
    assert result.__class__ is Allele, f'Expected parse("C*04:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_83():
    result = parse("C*04:83")
    assert result.__class__ is Allele, f'Expected parse("C*04:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_84():
    result = parse("C*04:84")
    assert result.__class__ is Allele, f'Expected parse("C*04:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_85():
    result = parse("C*04:85")
    assert result.__class__ is Allele, f'Expected parse("C*04:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_86():
    result = parse("C*04:86")
    assert result.__class__ is Allele, f'Expected parse("C*04:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_87():
    result = parse("C*04:87")
    assert result.__class__ is Allele, f'Expected parse("C*04:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_88N():
    result = parse("C*04:88N")
    assert result.__class__ is Allele, f'Expected parse("C*04:88N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:88N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_89():
    result = parse("C*04:89")
    assert result.__class__ is Allele, f'Expected parse("C*04:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_90():
    result = parse("C*04:90")
    assert result.__class__ is Allele, f'Expected parse("C*04:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_91():
    result = parse("C*04:91")
    assert result.__class__ is Allele, f'Expected parse("C*04:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_92():
    result = parse("C*04:92")
    assert result.__class__ is Allele, f'Expected parse("C*04:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_93N():
    result = parse("C*04:93N")
    assert result.__class__ is Allele, f'Expected parse("C*04:93N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:93N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_94_01():
    result = parse("C*04:94:01")
    assert result.__class__ is Allele, f'Expected parse("C*04:94:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:94:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_94_02():
    result = parse("C*04:94:02")
    assert result.__class__ is Allele, f'Expected parse("C*04:94:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:94:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_95N():
    result = parse("C*04:95N")
    assert result.__class__ is Allele, f'Expected parse("C*04:95N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:95N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_96():
    result = parse("C*04:96")
    assert result.__class__ is Allele, f'Expected parse("C*04:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_97():
    result = parse("C*04:97")
    assert result.__class__ is Allele, f'Expected parse("C*04:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_98_01():
    result = parse("C*04:98:01")
    assert result.__class__ is Allele, f'Expected parse("C*04:98:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:98:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_98_02():
    result = parse("C*04:98:02")
    assert result.__class__ is Allele, f'Expected parse("C*04:98:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*04:98:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_04_99():
    result = parse("C*04:99")
    assert result.__class__ is Allele, f'Expected parse("C*04:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*04:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_01():
    result = parse("C*05:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_02():
    result = parse("C*05:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_03():
    result = parse("C*05:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_04():
    result = parse("C*05:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_05():
    result = parse("C*05:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_06():
    result = parse("C*05:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_07():
    result = parse("C*05:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_08():
    result = parse("C*05:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_09():
    result = parse("C*05:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_10():
    result = parse("C*05:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_11():
    result = parse("C*05:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_12():
    result = parse("C*05:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_13():
    result = parse("C*05:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_14():
    result = parse("C*05:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_15():
    result = parse("C*05:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_16():
    result = parse("C*05:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_17():
    result = parse("C*05:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_18():
    result = parse("C*05:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_19():
    result = parse("C*05:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_20():
    result = parse("C*05:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_21():
    result = parse("C*05:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_22():
    result = parse("C*05:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_23():
    result = parse("C*05:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_24():
    result = parse("C*05:01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_25():
    result = parse("C*05:01:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_26():
    result = parse("C*05:01:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_27():
    result = parse("C*05:01:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_28():
    result = parse("C*05:01:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_29():
    result = parse("C*05:01:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_30():
    result = parse("C*05:01:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_31():
    result = parse("C*05:01:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_32():
    result = parse("C*05:01:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_33():
    result = parse("C*05:01:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_34():
    result = parse("C*05:01:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_35():
    result = parse("C*05:01:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_36():
    result = parse("C*05:01:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_37():
    result = parse("C*05:01:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_38():
    result = parse("C*05:01:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_39():
    result = parse("C*05:01:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_40():
    result = parse("C*05:01:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_41():
    result = parse("C*05:01:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_42():
    result = parse("C*05:01:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_43():
    result = parse("C*05:01:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_44():
    result = parse("C*05:01:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_45():
    result = parse("C*05:01:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:45") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_46():
    result = parse("C*05:01:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:46") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_47():
    result = parse("C*05:01:01:47")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:47") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_48():
    result = parse("C*05:01:01:48")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:48") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:48") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_01_49():
    result = parse("C*05:01:01:49")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:01:01:49") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:01:01:49") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_02():
    result = parse("C*05:01:02")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_03():
    result = parse("C*05:01:03")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_04():
    result = parse("C*05:01:04")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_05():
    result = parse("C*05:01:05")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_06():
    result = parse("C*05:01:06")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_07():
    result = parse("C*05:01:07")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_08():
    result = parse("C*05:01:08")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_09():
    result = parse("C*05:01:09")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_10():
    result = parse("C*05:01:10")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_11():
    result = parse("C*05:01:11")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_12():
    result = parse("C*05:01:12")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_13():
    result = parse("C*05:01:13")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_14():
    result = parse("C*05:01:14")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_15():
    result = parse("C*05:01:15")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_16():
    result = parse("C*05:01:16")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_17():
    result = parse("C*05:01:17")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_18():
    result = parse("C*05:01:18")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_19():
    result = parse("C*05:01:19")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_20():
    result = parse("C*05:01:20")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_21():
    result = parse("C*05:01:21")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_22():
    result = parse("C*05:01:22")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_23():
    result = parse("C*05:01:23")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_24():
    result = parse("C*05:01:24")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_25():
    result = parse("C*05:01:25")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_26():
    result = parse("C*05:01:26")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_27():
    result = parse("C*05:01:27")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_28():
    result = parse("C*05:01:28")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_29():
    result = parse("C*05:01:29")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_30():
    result = parse("C*05:01:30")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_31():
    result = parse("C*05:01:31")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_32():
    result = parse("C*05:01:32")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_33():
    result = parse("C*05:01:33")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_34():
    result = parse("C*05:01:34")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_35():
    result = parse("C*05:01:35")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_36():
    result = parse("C*05:01:36")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_37():
    result = parse("C*05:01:37")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_38():
    result = parse("C*05:01:38")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_39():
    result = parse("C*05:01:39")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_40():
    result = parse("C*05:01:40")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_41():
    result = parse("C*05:01:41")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_42():
    result = parse("C*05:01:42")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_43():
    result = parse("C*05:01:43")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_44():
    result = parse("C*05:01:44")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_45():
    result = parse("C*05:01:45")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_46():
    result = parse("C*05:01:46")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_47():
    result = parse("C*05:01:47")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_48():
    result = parse("C*05:01:48")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_49():
    result = parse("C*05:01:49")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_50():
    result = parse("C*05:01:50")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_51():
    result = parse("C*05:01:51")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_52():
    result = parse("C*05:01:52")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_01_53():
    result = parse("C*05:01:53")
    assert result.__class__ is Allele, f'Expected parse("C*05:01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:01:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_03():
    result = parse("C*05:03")
    assert result.__class__ is Allele, f'Expected parse("C*05:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_04_01():
    result = parse("C*05:04:01")
    assert result.__class__ is Allele, f'Expected parse("C*05:04:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_04_02():
    result = parse("C*05:04:02")
    assert result.__class__ is Allele, f'Expected parse("C*05:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_05_01():
    result = parse("C*05:05:01")
    assert result.__class__ is Allele, f'Expected parse("C*05:05:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_05_02():
    result = parse("C*05:05:02")
    assert result.__class__ is Allele, f'Expected parse("C*05:05:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_06():
    result = parse("C*05:06")
    assert result.__class__ is Allele, f'Expected parse("C*05:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_07N():
    result = parse("C*05:07N")
    assert result.__class__ is Allele, f'Expected parse("C*05:07N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:07N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_08():
    result = parse("C*05:08")
    assert result.__class__ is Allele, f'Expected parse("C*05:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_09_01():
    result = parse("C*05:09:01")
    assert result.__class__ is Allele, f'Expected parse("C*05:09:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:09:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_09_02():
    result = parse("C*05:09:02")
    assert result.__class__ is Allele, f'Expected parse("C*05:09:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:09:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_09_03():
    result = parse("C*05:09:03")
    assert result.__class__ is Allele, f'Expected parse("C*05:09:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:09:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_10():
    result = parse("C*05:10")
    assert result.__class__ is Allele, f'Expected parse("C*05:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_100():
    result = parse("C*05:100")
    assert result.__class__ is Allele, f'Expected parse("C*05:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_101():
    result = parse("C*05:101")
    assert result.__class__ is Allele, f'Expected parse("C*05:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_102():
    result = parse("C*05:102")
    assert result.__class__ is Allele, f'Expected parse("C*05:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_103_01():
    result = parse("C*05:103:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:103:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:103:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_103_02():
    result = parse("C*05:103:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:103:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:103:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_104():
    result = parse("C*05:104")
    assert result.__class__ is Allele, f'Expected parse("C*05:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_105():
    result = parse("C*05:105")
    assert result.__class__ is Allele, f'Expected parse("C*05:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_106_01():
    result = parse("C*05:106:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:106:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:106:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_106_02():
    result = parse("C*05:106:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:106:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:106:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_107():
    result = parse("C*05:107")
    assert result.__class__ is Allele, f'Expected parse("C*05:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_108():
    result = parse("C*05:108")
    assert result.__class__ is Allele, f'Expected parse("C*05:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_109():
    result = parse("C*05:109")
    assert result.__class__ is Allele, f'Expected parse("C*05:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_11():
    result = parse("C*05:11")
    assert result.__class__ is Allele, f'Expected parse("C*05:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_110():
    result = parse("C*05:110")
    assert result.__class__ is Allele, f'Expected parse("C*05:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_111():
    result = parse("C*05:111")
    assert result.__class__ is Allele, f'Expected parse("C*05:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_112():
    result = parse("C*05:112")
    assert result.__class__ is Allele, f'Expected parse("C*05:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_113N():
    result = parse("C*05:113N")
    assert result.__class__ is Allele, f'Expected parse("C*05:113N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:113N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_114():
    result = parse("C*05:114")
    assert result.__class__ is Allele, f'Expected parse("C*05:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_115():
    result = parse("C*05:115")
    assert result.__class__ is Allele, f'Expected parse("C*05:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_116():
    result = parse("C*05:116")
    assert result.__class__ is Allele, f'Expected parse("C*05:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_117():
    result = parse("C*05:117")
    assert result.__class__ is Allele, f'Expected parse("C*05:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_118():
    result = parse("C*05:118")
    assert result.__class__ is Allele, f'Expected parse("C*05:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_119():
    result = parse("C*05:119")
    assert result.__class__ is Allele, f'Expected parse("C*05:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_12():
    result = parse("C*05:12")
    assert result.__class__ is Allele, f'Expected parse("C*05:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_120():
    result = parse("C*05:120")
    assert result.__class__ is Allele, f'Expected parse("C*05:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_121():
    result = parse("C*05:121")
    assert result.__class__ is Allele, f'Expected parse("C*05:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_122():
    result = parse("C*05:122")
    assert result.__class__ is Allele, f'Expected parse("C*05:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_123():
    result = parse("C*05:123")
    assert result.__class__ is Allele, f'Expected parse("C*05:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_124():
    result = parse("C*05:124")
    assert result.__class__ is Allele, f'Expected parse("C*05:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_125():
    result = parse("C*05:125")
    assert result.__class__ is Allele, f'Expected parse("C*05:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_126():
    result = parse("C*05:126")
    assert result.__class__ is Allele, f'Expected parse("C*05:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_127():
    result = parse("C*05:127")
    assert result.__class__ is Allele, f'Expected parse("C*05:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_128N():
    result = parse("C*05:128N")
    assert result.__class__ is Allele, f'Expected parse("C*05:128N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:128N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_129():
    result = parse("C*05:129")
    assert result.__class__ is Allele, f'Expected parse("C*05:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_13():
    result = parse("C*05:13")
    assert result.__class__ is Allele, f'Expected parse("C*05:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_130():
    result = parse("C*05:130")
    assert result.__class__ is Allele, f'Expected parse("C*05:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_131():
    result = parse("C*05:131")
    assert result.__class__ is Allele, f'Expected parse("C*05:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_132():
    result = parse("C*05:132")
    assert result.__class__ is Allele, f'Expected parse("C*05:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_133():
    result = parse("C*05:133")
    assert result.__class__ is Allele, f'Expected parse("C*05:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_134():
    result = parse("C*05:134")
    assert result.__class__ is Allele, f'Expected parse("C*05:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_135():
    result = parse("C*05:135")
    assert result.__class__ is Allele, f'Expected parse("C*05:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_136():
    result = parse("C*05:136")
    assert result.__class__ is Allele, f'Expected parse("C*05:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_137():
    result = parse("C*05:137")
    assert result.__class__ is Allele, f'Expected parse("C*05:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_138():
    result = parse("C*05:138")
    assert result.__class__ is Allele, f'Expected parse("C*05:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_139():
    result = parse("C*05:139")
    assert result.__class__ is Allele, f'Expected parse("C*05:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_14():
    result = parse("C*05:14")
    assert result.__class__ is Allele, f'Expected parse("C*05:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_140():
    result = parse("C*05:140")
    assert result.__class__ is Allele, f'Expected parse("C*05:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_141():
    result = parse("C*05:141")
    assert result.__class__ is Allele, f'Expected parse("C*05:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_142():
    result = parse("C*05:142")
    assert result.__class__ is Allele, f'Expected parse("C*05:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_143():
    result = parse("C*05:143")
    assert result.__class__ is Allele, f'Expected parse("C*05:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_144():
    result = parse("C*05:144")
    assert result.__class__ is Allele, f'Expected parse("C*05:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_145():
    result = parse("C*05:145")
    assert result.__class__ is Allele, f'Expected parse("C*05:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_146():
    result = parse("C*05:146")
    assert result.__class__ is Allele, f'Expected parse("C*05:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_147():
    result = parse("C*05:147")
    assert result.__class__ is Allele, f'Expected parse("C*05:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_148():
    result = parse("C*05:148")
    assert result.__class__ is Allele, f'Expected parse("C*05:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_149():
    result = parse("C*05:149")
    assert result.__class__ is Allele, f'Expected parse("C*05:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_15():
    result = parse("C*05:15")
    assert result.__class__ is Allele, f'Expected parse("C*05:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_150():
    result = parse("C*05:150")
    assert result.__class__ is Allele, f'Expected parse("C*05:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_151():
    result = parse("C*05:151")
    assert result.__class__ is Allele, f'Expected parse("C*05:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_152():
    result = parse("C*05:152")
    assert result.__class__ is Allele, f'Expected parse("C*05:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_153N():
    result = parse("C*05:153N")
    assert result.__class__ is Allele, f'Expected parse("C*05:153N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:153N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_154N():
    result = parse("C*05:154N")
    assert result.__class__ is Allele, f'Expected parse("C*05:154N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:154N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_155():
    result = parse("C*05:155")
    assert result.__class__ is Allele, f'Expected parse("C*05:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_156():
    result = parse("C*05:156")
    assert result.__class__ is Allele, f'Expected parse("C*05:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_157():
    result = parse("C*05:157")
    assert result.__class__ is Allele, f'Expected parse("C*05:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_158():
    result = parse("C*05:158")
    assert result.__class__ is Allele, f'Expected parse("C*05:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_159():
    result = parse("C*05:159")
    assert result.__class__ is Allele, f'Expected parse("C*05:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_16():
    result = parse("C*05:16")
    assert result.__class__ is Allele, f'Expected parse("C*05:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_160():
    result = parse("C*05:160")
    assert result.__class__ is Allele, f'Expected parse("C*05:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_161():
    result = parse("C*05:161")
    assert result.__class__ is Allele, f'Expected parse("C*05:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_162():
    result = parse("C*05:162")
    assert result.__class__ is Allele, f'Expected parse("C*05:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_163():
    result = parse("C*05:163")
    assert result.__class__ is Allele, f'Expected parse("C*05:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_164():
    result = parse("C*05:164")
    assert result.__class__ is Allele, f'Expected parse("C*05:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_165():
    result = parse("C*05:165")
    assert result.__class__ is Allele, f'Expected parse("C*05:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_166():
    result = parse("C*05:166")
    assert result.__class__ is Allele, f'Expected parse("C*05:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_167():
    result = parse("C*05:167")
    assert result.__class__ is Allele, f'Expected parse("C*05:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_168():
    result = parse("C*05:168")
    assert result.__class__ is Allele, f'Expected parse("C*05:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_169N():
    result = parse("C*05:169N")
    assert result.__class__ is Allele, f'Expected parse("C*05:169N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:169N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_17():
    result = parse("C*05:17")
    assert result.__class__ is Allele, f'Expected parse("C*05:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_170():
    result = parse("C*05:170")
    assert result.__class__ is Allele, f'Expected parse("C*05:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_171_01_01():
    result = parse("C*05:171:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:171:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:171:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_171_01_02():
    result = parse("C*05:171:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:171:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:171:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_172():
    result = parse("C*05:172")
    assert result.__class__ is Allele, f'Expected parse("C*05:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_173():
    result = parse("C*05:173")
    assert result.__class__ is Allele, f'Expected parse("C*05:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_174():
    result = parse("C*05:174")
    assert result.__class__ is Allele, f'Expected parse("C*05:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_175N():
    result = parse("C*05:175N")
    assert result.__class__ is Allele, f'Expected parse("C*05:175N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:175N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_176():
    result = parse("C*05:176")
    assert result.__class__ is Allele, f'Expected parse("C*05:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_177():
    result = parse("C*05:177")
    assert result.__class__ is Allele, f'Expected parse("C*05:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_178_01_01():
    result = parse("C*05:178:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:178:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:178:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_178_01_02():
    result = parse("C*05:178:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:178:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:178:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_179():
    result = parse("C*05:179")
    assert result.__class__ is Allele, f'Expected parse("C*05:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_180N():
    result = parse("C*05:180N")
    assert result.__class__ is Allele, f'Expected parse("C*05:180N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:180N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_181():
    result = parse("C*05:181")
    assert result.__class__ is Allele, f'Expected parse("C*05:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_182():
    result = parse("C*05:182")
    assert result.__class__ is Allele, f'Expected parse("C*05:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_183():
    result = parse("C*05:183")
    assert result.__class__ is Allele, f'Expected parse("C*05:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_184():
    result = parse("C*05:184")
    assert result.__class__ is Allele, f'Expected parse("C*05:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_185():
    result = parse("C*05:185")
    assert result.__class__ is Allele, f'Expected parse("C*05:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_186():
    result = parse("C*05:186")
    assert result.__class__ is Allele, f'Expected parse("C*05:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_187():
    result = parse("C*05:187")
    assert result.__class__ is Allele, f'Expected parse("C*05:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_188():
    result = parse("C*05:188")
    assert result.__class__ is Allele, f'Expected parse("C*05:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_189():
    result = parse("C*05:189")
    assert result.__class__ is Allele, f'Expected parse("C*05:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_18_01():
    result = parse("C*05:18:01")
    assert result.__class__ is Allele, f'Expected parse("C*05:18:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:18:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_18_02():
    result = parse("C*05:18:02")
    assert result.__class__ is Allele, f'Expected parse("C*05:18:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:18:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_18_03():
    result = parse("C*05:18:03")
    assert result.__class__ is Allele, f'Expected parse("C*05:18:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:18:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_18_04():
    result = parse("C*05:18:04")
    assert result.__class__ is Allele, f'Expected parse("C*05:18:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:18:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_18_05():
    result = parse("C*05:18:05")
    assert result.__class__ is Allele, f'Expected parse("C*05:18:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:18:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_18_06():
    result = parse("C*05:18:06")
    assert result.__class__ is Allele, f'Expected parse("C*05:18:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:18:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_19():
    result = parse("C*05:19")
    assert result.__class__ is Allele, f'Expected parse("C*05:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_190():
    result = parse("C*05:190")
    assert result.__class__ is Allele, f'Expected parse("C*05:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_191():
    result = parse("C*05:191")
    assert result.__class__ is Allele, f'Expected parse("C*05:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_192():
    result = parse("C*05:192")
    assert result.__class__ is Allele, f'Expected parse("C*05:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_193():
    result = parse("C*05:193")
    assert result.__class__ is Allele, f'Expected parse("C*05:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_194():
    result = parse("C*05:194")
    assert result.__class__ is Allele, f'Expected parse("C*05:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_195():
    result = parse("C*05:195")
    assert result.__class__ is Allele, f'Expected parse("C*05:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_196():
    result = parse("C*05:196")
    assert result.__class__ is Allele, f'Expected parse("C*05:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_197():
    result = parse("C*05:197")
    assert result.__class__ is Allele, f'Expected parse("C*05:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_198():
    result = parse("C*05:198")
    assert result.__class__ is Allele, f'Expected parse("C*05:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_199():
    result = parse("C*05:199")
    assert result.__class__ is Allele, f'Expected parse("C*05:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_20():
    result = parse("C*05:20")
    assert result.__class__ is Allele, f'Expected parse("C*05:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_200():
    result = parse("C*05:200")
    assert result.__class__ is Allele, f'Expected parse("C*05:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_201():
    result = parse("C*05:201")
    assert result.__class__ is Allele, f'Expected parse("C*05:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_202Q():
    result = parse("C*05:202Q")
    assert result.__class__ is Allele, f'Expected parse("C*05:202Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:202Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_203():
    result = parse("C*05:203")
    assert result.__class__ is Allele, f'Expected parse("C*05:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_204():
    result = parse("C*05:204")
    assert result.__class__ is Allele, f'Expected parse("C*05:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_205():
    result = parse("C*05:205")
    assert result.__class__ is Allele, f'Expected parse("C*05:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_206():
    result = parse("C*05:206")
    assert result.__class__ is Allele, f'Expected parse("C*05:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_207():
    result = parse("C*05:207")
    assert result.__class__ is Allele, f'Expected parse("C*05:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_208N():
    result = parse("C*05:208N")
    assert result.__class__ is Allele, f'Expected parse("C*05:208N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:208N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_209():
    result = parse("C*05:209")
    assert result.__class__ is Allele, f'Expected parse("C*05:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_21():
    result = parse("C*05:21")
    assert result.__class__ is Allele, f'Expected parse("C*05:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_210():
    result = parse("C*05:210")
    assert result.__class__ is Allele, f'Expected parse("C*05:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_211():
    result = parse("C*05:211")
    assert result.__class__ is Allele, f'Expected parse("C*05:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_212():
    result = parse("C*05:212")
    assert result.__class__ is Allele, f'Expected parse("C*05:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_213N():
    result = parse("C*05:213N")
    assert result.__class__ is Allele, f'Expected parse("C*05:213N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:213N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_214():
    result = parse("C*05:214")
    assert result.__class__ is Allele, f'Expected parse("C*05:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_215():
    result = parse("C*05:215")
    assert result.__class__ is Allele, f'Expected parse("C*05:215") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_216_01_01():
    result = parse("C*05:216:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:216:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:216:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_216_01_02():
    result = parse("C*05:216:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:216:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:216:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_217():
    result = parse("C*05:217")
    assert result.__class__ is Allele, f'Expected parse("C*05:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_218():
    result = parse("C*05:218")
    assert result.__class__ is Allele, f'Expected parse("C*05:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_219():
    result = parse("C*05:219")
    assert result.__class__ is Allele, f'Expected parse("C*05:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_220():
    result = parse("C*05:220")
    assert result.__class__ is Allele, f'Expected parse("C*05:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_221():
    result = parse("C*05:221")
    assert result.__class__ is Allele, f'Expected parse("C*05:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_222():
    result = parse("C*05:222")
    assert result.__class__ is Allele, f'Expected parse("C*05:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_223():
    result = parse("C*05:223")
    assert result.__class__ is Allele, f'Expected parse("C*05:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_224():
    result = parse("C*05:224")
    assert result.__class__ is Allele, f'Expected parse("C*05:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_225():
    result = parse("C*05:225")
    assert result.__class__ is Allele, f'Expected parse("C*05:225") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_226():
    result = parse("C*05:226")
    assert result.__class__ is Allele, f'Expected parse("C*05:226") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_227():
    result = parse("C*05:227")
    assert result.__class__ is Allele, f'Expected parse("C*05:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_228():
    result = parse("C*05:228")
    assert result.__class__ is Allele, f'Expected parse("C*05:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_229():
    result = parse("C*05:229")
    assert result.__class__ is Allele, f'Expected parse("C*05:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_22_01():
    result = parse("C*05:22:01")
    assert result.__class__ is Allele, f'Expected parse("C*05:22:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:22:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_22_02():
    result = parse("C*05:22:02")
    assert result.__class__ is Allele, f'Expected parse("C*05:22:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:22:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_23():
    result = parse("C*05:23")
    assert result.__class__ is Allele, f'Expected parse("C*05:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_230():
    result = parse("C*05:230")
    assert result.__class__ is Allele, f'Expected parse("C*05:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_231():
    result = parse("C*05:231")
    assert result.__class__ is Allele, f'Expected parse("C*05:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_232():
    result = parse("C*05:232")
    assert result.__class__ is Allele, f'Expected parse("C*05:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_233():
    result = parse("C*05:233")
    assert result.__class__ is Allele, f'Expected parse("C*05:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_234():
    result = parse("C*05:234")
    assert result.__class__ is Allele, f'Expected parse("C*05:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_235():
    result = parse("C*05:235")
    assert result.__class__ is Allele, f'Expected parse("C*05:235") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_236():
    result = parse("C*05:236")
    assert result.__class__ is Allele, f'Expected parse("C*05:236") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_237():
    result = parse("C*05:237")
    assert result.__class__ is Allele, f'Expected parse("C*05:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_238():
    result = parse("C*05:238")
    assert result.__class__ is Allele, f'Expected parse("C*05:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_239N():
    result = parse("C*05:239N")
    assert result.__class__ is Allele, f'Expected parse("C*05:239N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:239N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_24():
    result = parse("C*05:24")
    assert result.__class__ is Allele, f'Expected parse("C*05:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_25():
    result = parse("C*05:25")
    assert result.__class__ is Allele, f'Expected parse("C*05:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_26():
    result = parse("C*05:26")
    assert result.__class__ is Allele, f'Expected parse("C*05:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_27():
    result = parse("C*05:27")
    assert result.__class__ is Allele, f'Expected parse("C*05:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_28():
    result = parse("C*05:28")
    assert result.__class__ is Allele, f'Expected parse("C*05:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_29_01():
    result = parse("C*05:29:01")
    assert result.__class__ is Allele, f'Expected parse("C*05:29:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:29:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_29_02():
    result = parse("C*05:29:02")
    assert result.__class__ is Allele, f'Expected parse("C*05:29:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:29:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_30():
    result = parse("C*05:30")
    assert result.__class__ is Allele, f'Expected parse("C*05:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_31():
    result = parse("C*05:31")
    assert result.__class__ is Allele, f'Expected parse("C*05:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_32():
    result = parse("C*05:32")
    assert result.__class__ is Allele, f'Expected parse("C*05:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_33():
    result = parse("C*05:33")
    assert result.__class__ is Allele, f'Expected parse("C*05:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_34():
    result = parse("C*05:34")
    assert result.__class__ is Allele, f'Expected parse("C*05:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_35():
    result = parse("C*05:35")
    assert result.__class__ is Allele, f'Expected parse("C*05:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_36():
    result = parse("C*05:36")
    assert result.__class__ is Allele, f'Expected parse("C*05:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_37():
    result = parse("C*05:37")
    assert result.__class__ is Allele, f'Expected parse("C*05:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_38():
    result = parse("C*05:38")
    assert result.__class__ is Allele, f'Expected parse("C*05:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_39():
    result = parse("C*05:39")
    assert result.__class__ is Allele, f'Expected parse("C*05:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_40():
    result = parse("C*05:40")
    assert result.__class__ is Allele, f'Expected parse("C*05:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_41():
    result = parse("C*05:41")
    assert result.__class__ is Allele, f'Expected parse("C*05:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_42():
    result = parse("C*05:42")
    assert result.__class__ is Allele, f'Expected parse("C*05:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_43():
    result = parse("C*05:43")
    assert result.__class__ is Allele, f'Expected parse("C*05:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_44_01():
    result = parse("C*05:44:01")
    assert result.__class__ is Allele, f'Expected parse("C*05:44:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:44:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_44_02():
    result = parse("C*05:44:02")
    assert result.__class__ is Allele, f'Expected parse("C*05:44:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:44:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_45():
    result = parse("C*05:45")
    assert result.__class__ is Allele, f'Expected parse("C*05:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_46_01_01():
    result = parse("C*05:46:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:46:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:46:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_46_01_02():
    result = parse("C*05:46:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*05:46:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*05:46:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_47():
    result = parse("C*05:47")
    assert result.__class__ is Allele, f'Expected parse("C*05:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_48N():
    result = parse("C*05:48N")
    assert result.__class__ is Allele, f'Expected parse("C*05:48N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:48N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_49():
    result = parse("C*05:49")
    assert result.__class__ is Allele, f'Expected parse("C*05:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_50():
    result = parse("C*05:50")
    assert result.__class__ is Allele, f'Expected parse("C*05:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_51Q():
    result = parse("C*05:51Q")
    assert result.__class__ is Allele, f'Expected parse("C*05:51Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:51Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_52():
    result = parse("C*05:52")
    assert result.__class__ is Allele, f'Expected parse("C*05:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_53():
    result = parse("C*05:53")
    assert result.__class__ is Allele, f'Expected parse("C*05:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_54():
    result = parse("C*05:54")
    assert result.__class__ is Allele, f'Expected parse("C*05:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_55():
    result = parse("C*05:55")
    assert result.__class__ is Allele, f'Expected parse("C*05:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_56():
    result = parse("C*05:56")
    assert result.__class__ is Allele, f'Expected parse("C*05:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_57():
    result = parse("C*05:57")
    assert result.__class__ is Allele, f'Expected parse("C*05:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_58_01():
    result = parse("C*05:58:01")
    assert result.__class__ is Allele, f'Expected parse("C*05:58:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:58:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_58_02():
    result = parse("C*05:58:02")
    assert result.__class__ is Allele, f'Expected parse("C*05:58:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:58:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_58_03():
    result = parse("C*05:58:03")
    assert result.__class__ is Allele, f'Expected parse("C*05:58:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:58:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_58_04():
    result = parse("C*05:58:04")
    assert result.__class__ is Allele, f'Expected parse("C*05:58:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:58:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_59():
    result = parse("C*05:59")
    assert result.__class__ is Allele, f'Expected parse("C*05:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_60():
    result = parse("C*05:60")
    assert result.__class__ is Allele, f'Expected parse("C*05:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_61():
    result = parse("C*05:61")
    assert result.__class__ is Allele, f'Expected parse("C*05:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_62():
    result = parse("C*05:62")
    assert result.__class__ is Allele, f'Expected parse("C*05:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_63():
    result = parse("C*05:63")
    assert result.__class__ is Allele, f'Expected parse("C*05:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_64_01():
    result = parse("C*05:64:01")
    assert result.__class__ is Allele, f'Expected parse("C*05:64:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:64:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_64_02():
    result = parse("C*05:64:02")
    assert result.__class__ is Allele, f'Expected parse("C*05:64:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:64:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_65():
    result = parse("C*05:65")
    assert result.__class__ is Allele, f'Expected parse("C*05:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_66():
    result = parse("C*05:66")
    assert result.__class__ is Allele, f'Expected parse("C*05:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_67():
    result = parse("C*05:67")
    assert result.__class__ is Allele, f'Expected parse("C*05:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_68():
    result = parse("C*05:68")
    assert result.__class__ is Allele, f'Expected parse("C*05:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_69():
    result = parse("C*05:69")
    assert result.__class__ is Allele, f'Expected parse("C*05:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_70():
    result = parse("C*05:70")
    assert result.__class__ is Allele, f'Expected parse("C*05:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_71():
    result = parse("C*05:71")
    assert result.__class__ is Allele, f'Expected parse("C*05:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_72():
    result = parse("C*05:72")
    assert result.__class__ is Allele, f'Expected parse("C*05:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_73():
    result = parse("C*05:73")
    assert result.__class__ is Allele, f'Expected parse("C*05:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_74():
    result = parse("C*05:74")
    assert result.__class__ is Allele, f'Expected parse("C*05:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_75():
    result = parse("C*05:75")
    assert result.__class__ is Allele, f'Expected parse("C*05:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_76():
    result = parse("C*05:76")
    assert result.__class__ is Allele, f'Expected parse("C*05:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_77():
    result = parse("C*05:77")
    assert result.__class__ is Allele, f'Expected parse("C*05:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_78_01():
    result = parse("C*05:78:01")
    assert result.__class__ is Allele, f'Expected parse("C*05:78:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:78:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_78_02():
    result = parse("C*05:78:02")
    assert result.__class__ is Allele, f'Expected parse("C*05:78:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*05:78:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_79():
    result = parse("C*05:79")
    assert result.__class__ is Allele, f'Expected parse("C*05:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_80():
    result = parse("C*05:80")
    assert result.__class__ is Allele, f'Expected parse("C*05:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_81():
    result = parse("C*05:81")
    assert result.__class__ is Allele, f'Expected parse("C*05:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_82():
    result = parse("C*05:82")
    assert result.__class__ is Allele, f'Expected parse("C*05:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_83():
    result = parse("C*05:83")
    assert result.__class__ is Allele, f'Expected parse("C*05:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_84():
    result = parse("C*05:84")
    assert result.__class__ is Allele, f'Expected parse("C*05:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_85():
    result = parse("C*05:85")
    assert result.__class__ is Allele, f'Expected parse("C*05:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_86():
    result = parse("C*05:86")
    assert result.__class__ is Allele, f'Expected parse("C*05:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_87():
    result = parse("C*05:87")
    assert result.__class__ is Allele, f'Expected parse("C*05:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_88():
    result = parse("C*05:88")
    assert result.__class__ is Allele, f'Expected parse("C*05:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_89():
    result = parse("C*05:89")
    assert result.__class__ is Allele, f'Expected parse("C*05:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_90():
    result = parse("C*05:90")
    assert result.__class__ is Allele, f'Expected parse("C*05:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_91N():
    result = parse("C*05:91N")
    assert result.__class__ is Allele, f'Expected parse("C*05:91N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:91N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_92N():
    result = parse("C*05:92N")
    assert result.__class__ is Allele, f'Expected parse("C*05:92N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:92N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_93():
    result = parse("C*05:93")
    assert result.__class__ is Allele, f'Expected parse("C*05:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_94():
    result = parse("C*05:94")
    assert result.__class__ is Allele, f'Expected parse("C*05:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_95():
    result = parse("C*05:95")
    assert result.__class__ is Allele, f'Expected parse("C*05:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_96():
    result = parse("C*05:96")
    assert result.__class__ is Allele, f'Expected parse("C*05:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_97():
    result = parse("C*05:97")
    assert result.__class__ is Allele, f'Expected parse("C*05:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_98():
    result = parse("C*05:98")
    assert result.__class__ is Allele, f'Expected parse("C*05:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_05_99N():
    result = parse("C*05:99N")
    assert result.__class__ is Allele, f'Expected parse("C*05:99N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*05:99N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_01():
    result = parse("C*06:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_02():
    result = parse("C*06:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_03():
    result = parse("C*06:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_04():
    result = parse("C*06:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_05():
    result = parse("C*06:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_06():
    result = parse("C*06:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_07():
    result = parse("C*06:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_08():
    result = parse("C*06:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_09():
    result = parse("C*06:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_10():
    result = parse("C*06:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_11():
    result = parse("C*06:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_12():
    result = parse("C*06:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_13():
    result = parse("C*06:02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_14():
    result = parse("C*06:02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_15():
    result = parse("C*06:02:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_16():
    result = parse("C*06:02:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_17():
    result = parse("C*06:02:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_18():
    result = parse("C*06:02:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_19():
    result = parse("C*06:02:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_20():
    result = parse("C*06:02:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_21():
    result = parse("C*06:02:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_22():
    result = parse("C*06:02:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_23():
    result = parse("C*06:02:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_24():
    result = parse("C*06:02:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_25():
    result = parse("C*06:02:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_26():
    result = parse("C*06:02:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_27():
    result = parse("C*06:02:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_28():
    result = parse("C*06:02:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_29():
    result = parse("C*06:02:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_30():
    result = parse("C*06:02:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_31():
    result = parse("C*06:02:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_32():
    result = parse("C*06:02:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_33():
    result = parse("C*06:02:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_34():
    result = parse("C*06:02:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_35():
    result = parse("C*06:02:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_36():
    result = parse("C*06:02:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_37():
    result = parse("C*06:02:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_38():
    result = parse("C*06:02:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_39():
    result = parse("C*06:02:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_40():
    result = parse("C*06:02:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_41():
    result = parse("C*06:02:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_42():
    result = parse("C*06:02:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_43():
    result = parse("C*06:02:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_44():
    result = parse("C*06:02:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_01_45():
    result = parse("C*06:02:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:01:45") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_03():
    result = parse("C*06:02:03")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_04():
    result = parse("C*06:02:04")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_05():
    result = parse("C*06:02:05")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_06():
    result = parse("C*06:02:06")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_07():
    result = parse("C*06:02:07")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_08():
    result = parse("C*06:02:08")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_09():
    result = parse("C*06:02:09")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_10():
    result = parse("C*06:02:10")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_11():
    result = parse("C*06:02:11")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_12():
    result = parse("C*06:02:12")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_13():
    result = parse("C*06:02:13")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_14():
    result = parse("C*06:02:14")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_15():
    result = parse("C*06:02:15")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_16():
    result = parse("C*06:02:16")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_17():
    result = parse("C*06:02:17")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_18():
    result = parse("C*06:02:18")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_19():
    result = parse("C*06:02:19")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_20():
    result = parse("C*06:02:20")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_21():
    result = parse("C*06:02:21")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_22():
    result = parse("C*06:02:22")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_23():
    result = parse("C*06:02:23")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_24():
    result = parse("C*06:02:24")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_25():
    result = parse("C*06:02:25")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_26():
    result = parse("C*06:02:26")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_27():
    result = parse("C*06:02:27")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_28():
    result = parse("C*06:02:28")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_29():
    result = parse("C*06:02:29")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_30():
    result = parse("C*06:02:30")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_31():
    result = parse("C*06:02:31")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_32():
    result = parse("C*06:02:32")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_33():
    result = parse("C*06:02:33")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_34():
    result = parse("C*06:02:34")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_35():
    result = parse("C*06:02:35")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_36():
    result = parse("C*06:02:36")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_37():
    result = parse("C*06:02:37")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_38():
    result = parse("C*06:02:38")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_39():
    result = parse("C*06:02:39")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_40():
    result = parse("C*06:02:40")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_41():
    result = parse("C*06:02:41")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_42():
    result = parse("C*06:02:42")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_43():
    result = parse("C*06:02:43")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_44():
    result = parse("C*06:02:44")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_45():
    result = parse("C*06:02:45")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_46():
    result = parse("C*06:02:46")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_47():
    result = parse("C*06:02:47")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_48():
    result = parse("C*06:02:48")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_49():
    result = parse("C*06:02:49")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_50_01():
    result = parse("C*06:02:50:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:50:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:50:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_50_02():
    result = parse("C*06:02:50:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:02:50:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:02:50:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_51():
    result = parse("C*06:02:51")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_52():
    result = parse("C*06:02:52")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_53():
    result = parse("C*06:02:53")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_54():
    result = parse("C*06:02:54")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_55():
    result = parse("C*06:02:55")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_56():
    result = parse("C*06:02:56")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_57():
    result = parse("C*06:02:57")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_58():
    result = parse("C*06:02:58")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_59():
    result = parse("C*06:02:59")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_60():
    result = parse("C*06:02:60")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_61():
    result = parse("C*06:02:61")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_62():
    result = parse("C*06:02:62")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_63():
    result = parse("C*06:02:63")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_64():
    result = parse("C*06:02:64")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_65():
    result = parse("C*06:02:65")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_66():
    result = parse("C*06:02:66")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:66") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:66") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_67():
    result = parse("C*06:02:67")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:67") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:67") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_68():
    result = parse("C*06:02:68")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:68") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:68") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_69():
    result = parse("C*06:02:69")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:69") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:69") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_70():
    result = parse("C*06:02:70")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:70") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:70") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_71():
    result = parse("C*06:02:71")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:71") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:71") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_72():
    result = parse("C*06:02:72")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:72") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:72") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_73():
    result = parse("C*06:02:73")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:73") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:73") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_74():
    result = parse("C*06:02:74")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:74") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:74") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_75():
    result = parse("C*06:02:75")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:75") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:75") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_76():
    result = parse("C*06:02:76")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:76") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:76") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_77():
    result = parse("C*06:02:77")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:77") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:77") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_78():
    result = parse("C*06:02:78")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:78") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:78") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_79():
    result = parse("C*06:02:79")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:79") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:79") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_80():
    result = parse("C*06:02:80")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:80") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:80") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_81():
    result = parse("C*06:02:81")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:81") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:81") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_02_82():
    result = parse("C*06:02:82")
    assert result.__class__ is Allele, f'Expected parse("C*06:02:82") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:02:82") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_03_01():
    result = parse("C*06:03:01")
    assert result.__class__ is Allele, f'Expected parse("C*06:03:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:03:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_03_02():
    result = parse("C*06:03:02")
    assert result.__class__ is Allele, f'Expected parse("C*06:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_04_01():
    result = parse("C*06:04:01")
    assert result.__class__ is Allele, f'Expected parse("C*06:04:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_04_02():
    result = parse("C*06:04:02")
    assert result.__class__ is Allele, f'Expected parse("C*06:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_05():
    result = parse("C*06:05")
    assert result.__class__ is Allele, f'Expected parse("C*06:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_06():
    result = parse("C*06:06")
    assert result.__class__ is Allele, f'Expected parse("C*06:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_07():
    result = parse("C*06:07")
    assert result.__class__ is Allele, f'Expected parse("C*06:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_08():
    result = parse("C*06:08")
    assert result.__class__ is Allele, f'Expected parse("C*06:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_09_01():
    result = parse("C*06:09:01")
    assert result.__class__ is Allele, f'Expected parse("C*06:09:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:09:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_09_02():
    result = parse("C*06:09:02")
    assert result.__class__ is Allele, f'Expected parse("C*06:09:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:09:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_10():
    result = parse("C*06:10")
    assert result.__class__ is Allele, f'Expected parse("C*06:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_100():
    result = parse("C*06:100")
    assert result.__class__ is Allele, f'Expected parse("C*06:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_101():
    result = parse("C*06:101")
    assert result.__class__ is Allele, f'Expected parse("C*06:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_102_01():
    result = parse("C*06:102:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:102:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:102:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_102_02():
    result = parse("C*06:102:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:102:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:102:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_103():
    result = parse("C*06:103")
    assert result.__class__ is Allele, f'Expected parse("C*06:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_104():
    result = parse("C*06:104")
    assert result.__class__ is Allele, f'Expected parse("C*06:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_105():
    result = parse("C*06:105")
    assert result.__class__ is Allele, f'Expected parse("C*06:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_106_01():
    result = parse("C*06:106:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:106:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:106:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_106_02():
    result = parse("C*06:106:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:106:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:106:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_107():
    result = parse("C*06:107")
    assert result.__class__ is Allele, f'Expected parse("C*06:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_108():
    result = parse("C*06:108")
    assert result.__class__ is Allele, f'Expected parse("C*06:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_109():
    result = parse("C*06:109")
    assert result.__class__ is Allele, f'Expected parse("C*06:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_11():
    result = parse("C*06:11")
    assert result.__class__ is Allele, f'Expected parse("C*06:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_110():
    result = parse("C*06:110")
    assert result.__class__ is Allele, f'Expected parse("C*06:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_111():
    result = parse("C*06:111")
    assert result.__class__ is Allele, f'Expected parse("C*06:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_112():
    result = parse("C*06:112")
    assert result.__class__ is Allele, f'Expected parse("C*06:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_113():
    result = parse("C*06:113")
    assert result.__class__ is Allele, f'Expected parse("C*06:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_114():
    result = parse("C*06:114")
    assert result.__class__ is Allele, f'Expected parse("C*06:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_115():
    result = parse("C*06:115")
    assert result.__class__ is Allele, f'Expected parse("C*06:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_116N():
    result = parse("C*06:116N")
    assert result.__class__ is Allele, f'Expected parse("C*06:116N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:116N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_117():
    result = parse("C*06:117")
    assert result.__class__ is Allele, f'Expected parse("C*06:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_118():
    result = parse("C*06:118")
    assert result.__class__ is Allele, f'Expected parse("C*06:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_119():
    result = parse("C*06:119")
    assert result.__class__ is Allele, f'Expected parse("C*06:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_12():
    result = parse("C*06:12")
    assert result.__class__ is Allele, f'Expected parse("C*06:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_120():
    result = parse("C*06:120")
    assert result.__class__ is Allele, f'Expected parse("C*06:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_121():
    result = parse("C*06:121")
    assert result.__class__ is Allele, f'Expected parse("C*06:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_122():
    result = parse("C*06:122")
    assert result.__class__ is Allele, f'Expected parse("C*06:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_123():
    result = parse("C*06:123")
    assert result.__class__ is Allele, f'Expected parse("C*06:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_124():
    result = parse("C*06:124")
    assert result.__class__ is Allele, f'Expected parse("C*06:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_125():
    result = parse("C*06:125")
    assert result.__class__ is Allele, f'Expected parse("C*06:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_126():
    result = parse("C*06:126")
    assert result.__class__ is Allele, f'Expected parse("C*06:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_127_01_01():
    result = parse("C*06:127:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:127:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:127:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_127_01_02():
    result = parse("C*06:127:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:127:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:127:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_127_02():
    result = parse("C*06:127:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:127:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:127:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_128N():
    result = parse("C*06:128N")
    assert result.__class__ is Allele, f'Expected parse("C*06:128N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:128N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_129():
    result = parse("C*06:129")
    assert result.__class__ is Allele, f'Expected parse("C*06:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_13():
    result = parse("C*06:13")
    assert result.__class__ is Allele, f'Expected parse("C*06:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_130():
    result = parse("C*06:130")
    assert result.__class__ is Allele, f'Expected parse("C*06:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_131():
    result = parse("C*06:131")
    assert result.__class__ is Allele, f'Expected parse("C*06:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_132_01():
    result = parse("C*06:132:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:132:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:132:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_132_02():
    result = parse("C*06:132:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:132:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:132:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_133():
    result = parse("C*06:133")
    assert result.__class__ is Allele, f'Expected parse("C*06:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_134N():
    result = parse("C*06:134N")
    assert result.__class__ is Allele, f'Expected parse("C*06:134N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:134N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_135():
    result = parse("C*06:135")
    assert result.__class__ is Allele, f'Expected parse("C*06:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_136():
    result = parse("C*06:136")
    assert result.__class__ is Allele, f'Expected parse("C*06:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_137():
    result = parse("C*06:137")
    assert result.__class__ is Allele, f'Expected parse("C*06:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_138():
    result = parse("C*06:138")
    assert result.__class__ is Allele, f'Expected parse("C*06:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_139():
    result = parse("C*06:139")
    assert result.__class__ is Allele, f'Expected parse("C*06:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_14():
    result = parse("C*06:14")
    assert result.__class__ is Allele, f'Expected parse("C*06:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_140():
    result = parse("C*06:140")
    assert result.__class__ is Allele, f'Expected parse("C*06:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_141():
    result = parse("C*06:141")
    assert result.__class__ is Allele, f'Expected parse("C*06:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_142():
    result = parse("C*06:142")
    assert result.__class__ is Allele, f'Expected parse("C*06:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_143():
    result = parse("C*06:143")
    assert result.__class__ is Allele, f'Expected parse("C*06:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_144():
    result = parse("C*06:144")
    assert result.__class__ is Allele, f'Expected parse("C*06:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_145():
    result = parse("C*06:145")
    assert result.__class__ is Allele, f'Expected parse("C*06:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_146():
    result = parse("C*06:146")
    assert result.__class__ is Allele, f'Expected parse("C*06:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_147():
    result = parse("C*06:147")
    assert result.__class__ is Allele, f'Expected parse("C*06:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_148():
    result = parse("C*06:148")
    assert result.__class__ is Allele, f'Expected parse("C*06:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_149():
    result = parse("C*06:149")
    assert result.__class__ is Allele, f'Expected parse("C*06:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_15():
    result = parse("C*06:15")
    assert result.__class__ is Allele, f'Expected parse("C*06:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_150():
    result = parse("C*06:150")
    assert result.__class__ is Allele, f'Expected parse("C*06:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_151():
    result = parse("C*06:151")
    assert result.__class__ is Allele, f'Expected parse("C*06:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_152N():
    result = parse("C*06:152N")
    assert result.__class__ is Allele, f'Expected parse("C*06:152N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:152N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_153():
    result = parse("C*06:153")
    assert result.__class__ is Allele, f'Expected parse("C*06:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_154():
    result = parse("C*06:154")
    assert result.__class__ is Allele, f'Expected parse("C*06:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_155_01_01():
    result = parse("C*06:155:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:155:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:155:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_155_01_02():
    result = parse("C*06:155:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:155:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:155:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_156():
    result = parse("C*06:156")
    assert result.__class__ is Allele, f'Expected parse("C*06:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_157():
    result = parse("C*06:157")
    assert result.__class__ is Allele, f'Expected parse("C*06:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_158():
    result = parse("C*06:158")
    assert result.__class__ is Allele, f'Expected parse("C*06:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_159():
    result = parse("C*06:159")
    assert result.__class__ is Allele, f'Expected parse("C*06:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_160():
    result = parse("C*06:160")
    assert result.__class__ is Allele, f'Expected parse("C*06:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_161():
    result = parse("C*06:161")
    assert result.__class__ is Allele, f'Expected parse("C*06:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_162():
    result = parse("C*06:162")
    assert result.__class__ is Allele, f'Expected parse("C*06:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_163():
    result = parse("C*06:163")
    assert result.__class__ is Allele, f'Expected parse("C*06:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_164():
    result = parse("C*06:164")
    assert result.__class__ is Allele, f'Expected parse("C*06:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_165():
    result = parse("C*06:165")
    assert result.__class__ is Allele, f'Expected parse("C*06:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_166():
    result = parse("C*06:166")
    assert result.__class__ is Allele, f'Expected parse("C*06:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_167():
    result = parse("C*06:167")
    assert result.__class__ is Allele, f'Expected parse("C*06:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_168():
    result = parse("C*06:168")
    assert result.__class__ is Allele, f'Expected parse("C*06:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_169():
    result = parse("C*06:169")
    assert result.__class__ is Allele, f'Expected parse("C*06:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_16N():
    result = parse("C*06:16N")
    assert result.__class__ is Allele, f'Expected parse("C*06:16N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:16N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_17():
    result = parse("C*06:17")
    assert result.__class__ is Allele, f'Expected parse("C*06:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_170():
    result = parse("C*06:170")
    assert result.__class__ is Allele, f'Expected parse("C*06:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_171_01_01N():
    result = parse("C*06:171:01:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:171:01:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:171:01:01N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_171_01_02N():
    result = parse("C*06:171:01:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:171:01:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:171:01:02N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_172():
    result = parse("C*06:172")
    assert result.__class__ is Allele, f'Expected parse("C*06:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_173():
    result = parse("C*06:173")
    assert result.__class__ is Allele, f'Expected parse("C*06:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_174():
    result = parse("C*06:174")
    assert result.__class__ is Allele, f'Expected parse("C*06:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_175N():
    result = parse("C*06:175N")
    assert result.__class__ is Allele, f'Expected parse("C*06:175N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:175N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_176():
    result = parse("C*06:176")
    assert result.__class__ is Allele, f'Expected parse("C*06:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_177():
    result = parse("C*06:177")
    assert result.__class__ is Allele, f'Expected parse("C*06:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_178():
    result = parse("C*06:178")
    assert result.__class__ is Allele, f'Expected parse("C*06:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_179():
    result = parse("C*06:179")
    assert result.__class__ is Allele, f'Expected parse("C*06:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_18():
    result = parse("C*06:18")
    assert result.__class__ is Allele, f'Expected parse("C*06:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_180():
    result = parse("C*06:180")
    assert result.__class__ is Allele, f'Expected parse("C*06:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_181():
    result = parse("C*06:181")
    assert result.__class__ is Allele, f'Expected parse("C*06:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_182():
    result = parse("C*06:182")
    assert result.__class__ is Allele, f'Expected parse("C*06:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_183():
    result = parse("C*06:183")
    assert result.__class__ is Allele, f'Expected parse("C*06:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_184():
    result = parse("C*06:184")
    assert result.__class__ is Allele, f'Expected parse("C*06:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_185():
    result = parse("C*06:185")
    assert result.__class__ is Allele, f'Expected parse("C*06:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_186():
    result = parse("C*06:186")
    assert result.__class__ is Allele, f'Expected parse("C*06:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_187():
    result = parse("C*06:187")
    assert result.__class__ is Allele, f'Expected parse("C*06:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_188():
    result = parse("C*06:188")
    assert result.__class__ is Allele, f'Expected parse("C*06:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_189():
    result = parse("C*06:189")
    assert result.__class__ is Allele, f'Expected parse("C*06:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_19():
    result = parse("C*06:19")
    assert result.__class__ is Allele, f'Expected parse("C*06:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_190():
    result = parse("C*06:190")
    assert result.__class__ is Allele, f'Expected parse("C*06:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_191():
    result = parse("C*06:191")
    assert result.__class__ is Allele, f'Expected parse("C*06:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_192():
    result = parse("C*06:192")
    assert result.__class__ is Allele, f'Expected parse("C*06:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_193():
    result = parse("C*06:193")
    assert result.__class__ is Allele, f'Expected parse("C*06:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_194():
    result = parse("C*06:194")
    assert result.__class__ is Allele, f'Expected parse("C*06:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_195():
    result = parse("C*06:195")
    assert result.__class__ is Allele, f'Expected parse("C*06:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_196():
    result = parse("C*06:196")
    assert result.__class__ is Allele, f'Expected parse("C*06:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_197():
    result = parse("C*06:197")
    assert result.__class__ is Allele, f'Expected parse("C*06:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_198():
    result = parse("C*06:198")
    assert result.__class__ is Allele, f'Expected parse("C*06:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_199():
    result = parse("C*06:199")
    assert result.__class__ is Allele, f'Expected parse("C*06:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_20():
    result = parse("C*06:20")
    assert result.__class__ is Allele, f'Expected parse("C*06:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_200Q():
    result = parse("C*06:200Q")
    assert result.__class__ is Allele, f'Expected parse("C*06:200Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:200Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_201():
    result = parse("C*06:201")
    assert result.__class__ is Allele, f'Expected parse("C*06:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_202():
    result = parse("C*06:202")
    assert result.__class__ is Allele, f'Expected parse("C*06:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_203():
    result = parse("C*06:203")
    assert result.__class__ is Allele, f'Expected parse("C*06:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_204():
    result = parse("C*06:204")
    assert result.__class__ is Allele, f'Expected parse("C*06:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_205():
    result = parse("C*06:205")
    assert result.__class__ is Allele, f'Expected parse("C*06:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_206():
    result = parse("C*06:206")
    assert result.__class__ is Allele, f'Expected parse("C*06:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_207():
    result = parse("C*06:207")
    assert result.__class__ is Allele, f'Expected parse("C*06:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_208N():
    result = parse("C*06:208N")
    assert result.__class__ is Allele, f'Expected parse("C*06:208N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:208N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_209():
    result = parse("C*06:209")
    assert result.__class__ is Allele, f'Expected parse("C*06:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_21():
    result = parse("C*06:21")
    assert result.__class__ is Allele, f'Expected parse("C*06:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_210():
    result = parse("C*06:210")
    assert result.__class__ is Allele, f'Expected parse("C*06:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_211_01_01N():
    result = parse("C*06:211:01:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:211:01:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:211:01:01N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_211_01_02N():
    result = parse("C*06:211:01:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*06:211:01:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*06:211:01:02N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_212():
    result = parse("C*06:212")
    assert result.__class__ is Allele, f'Expected parse("C*06:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_213():
    result = parse("C*06:213")
    assert result.__class__ is Allele, f'Expected parse("C*06:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_214():
    result = parse("C*06:214")
    assert result.__class__ is Allele, f'Expected parse("C*06:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_215N():
    result = parse("C*06:215N")
    assert result.__class__ is Allele, f'Expected parse("C*06:215N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:215N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_216():
    result = parse("C*06:216")
    assert result.__class__ is Allele, f'Expected parse("C*06:216") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_217():
    result = parse("C*06:217")
    assert result.__class__ is Allele, f'Expected parse("C*06:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_218():
    result = parse("C*06:218")
    assert result.__class__ is Allele, f'Expected parse("C*06:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_219():
    result = parse("C*06:219")
    assert result.__class__ is Allele, f'Expected parse("C*06:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_22():
    result = parse("C*06:22")
    assert result.__class__ is Allele, f'Expected parse("C*06:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_220N():
    result = parse("C*06:220N")
    assert result.__class__ is Allele, f'Expected parse("C*06:220N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:220N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_221():
    result = parse("C*06:221")
    assert result.__class__ is Allele, f'Expected parse("C*06:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_222():
    result = parse("C*06:222")
    assert result.__class__ is Allele, f'Expected parse("C*06:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_223():
    result = parse("C*06:223")
    assert result.__class__ is Allele, f'Expected parse("C*06:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_224():
    result = parse("C*06:224")
    assert result.__class__ is Allele, f'Expected parse("C*06:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_225():
    result = parse("C*06:225")
    assert result.__class__ is Allele, f'Expected parse("C*06:225") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_226():
    result = parse("C*06:226")
    assert result.__class__ is Allele, f'Expected parse("C*06:226") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_227():
    result = parse("C*06:227")
    assert result.__class__ is Allele, f'Expected parse("C*06:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_228():
    result = parse("C*06:228")
    assert result.__class__ is Allele, f'Expected parse("C*06:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_229():
    result = parse("C*06:229")
    assert result.__class__ is Allele, f'Expected parse("C*06:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_23():
    result = parse("C*06:23")
    assert result.__class__ is Allele, f'Expected parse("C*06:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_230():
    result = parse("C*06:230")
    assert result.__class__ is Allele, f'Expected parse("C*06:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_231():
    result = parse("C*06:231")
    assert result.__class__ is Allele, f'Expected parse("C*06:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_232():
    result = parse("C*06:232")
    assert result.__class__ is Allele, f'Expected parse("C*06:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_233():
    result = parse("C*06:233")
    assert result.__class__ is Allele, f'Expected parse("C*06:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_234():
    result = parse("C*06:234")
    assert result.__class__ is Allele, f'Expected parse("C*06:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_235():
    result = parse("C*06:235")
    assert result.__class__ is Allele, f'Expected parse("C*06:235") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_236():
    result = parse("C*06:236")
    assert result.__class__ is Allele, f'Expected parse("C*06:236") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_237():
    result = parse("C*06:237")
    assert result.__class__ is Allele, f'Expected parse("C*06:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_238():
    result = parse("C*06:238")
    assert result.__class__ is Allele, f'Expected parse("C*06:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_239():
    result = parse("C*06:239")
    assert result.__class__ is Allele, f'Expected parse("C*06:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_24():
    result = parse("C*06:24")
    assert result.__class__ is Allele, f'Expected parse("C*06:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_240():
    result = parse("C*06:240")
    assert result.__class__ is Allele, f'Expected parse("C*06:240") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_241():
    result = parse("C*06:241")
    assert result.__class__ is Allele, f'Expected parse("C*06:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_242():
    result = parse("C*06:242")
    assert result.__class__ is Allele, f'Expected parse("C*06:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_243():
    result = parse("C*06:243")
    assert result.__class__ is Allele, f'Expected parse("C*06:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_244():
    result = parse("C*06:244")
    assert result.__class__ is Allele, f'Expected parse("C*06:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_245():
    result = parse("C*06:245")
    assert result.__class__ is Allele, f'Expected parse("C*06:245") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_246():
    result = parse("C*06:246")
    assert result.__class__ is Allele, f'Expected parse("C*06:246") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_247():
    result = parse("C*06:247")
    assert result.__class__ is Allele, f'Expected parse("C*06:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_248():
    result = parse("C*06:248")
    assert result.__class__ is Allele, f'Expected parse("C*06:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_249():
    result = parse("C*06:249")
    assert result.__class__ is Allele, f'Expected parse("C*06:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_25():
    result = parse("C*06:25")
    assert result.__class__ is Allele, f'Expected parse("C*06:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_250():
    result = parse("C*06:250")
    assert result.__class__ is Allele, f'Expected parse("C*06:250") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_251():
    result = parse("C*06:251")
    assert result.__class__ is Allele, f'Expected parse("C*06:251") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_252():
    result = parse("C*06:252")
    assert result.__class__ is Allele, f'Expected parse("C*06:252") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_253():
    result = parse("C*06:253")
    assert result.__class__ is Allele, f'Expected parse("C*06:253") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_254():
    result = parse("C*06:254")
    assert result.__class__ is Allele, f'Expected parse("C*06:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_255():
    result = parse("C*06:255")
    assert result.__class__ is Allele, f'Expected parse("C*06:255") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_256():
    result = parse("C*06:256")
    assert result.__class__ is Allele, f'Expected parse("C*06:256") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_257N():
    result = parse("C*06:257N")
    assert result.__class__ is Allele, f'Expected parse("C*06:257N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:257N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_258():
    result = parse("C*06:258")
    assert result.__class__ is Allele, f'Expected parse("C*06:258") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_259N():
    result = parse("C*06:259N")
    assert result.__class__ is Allele, f'Expected parse("C*06:259N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:259N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_26():
    result = parse("C*06:26")
    assert result.__class__ is Allele, f'Expected parse("C*06:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_260():
    result = parse("C*06:260")
    assert result.__class__ is Allele, f'Expected parse("C*06:260") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_261():
    result = parse("C*06:261")
    assert result.__class__ is Allele, f'Expected parse("C*06:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_262():
    result = parse("C*06:262")
    assert result.__class__ is Allele, f'Expected parse("C*06:262") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_263N():
    result = parse("C*06:263N")
    assert result.__class__ is Allele, f'Expected parse("C*06:263N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:263N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_264():
    result = parse("C*06:264")
    assert result.__class__ is Allele, f'Expected parse("C*06:264") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_265():
    result = parse("C*06:265")
    assert result.__class__ is Allele, f'Expected parse("C*06:265") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_266():
    result = parse("C*06:266")
    assert result.__class__ is Allele, f'Expected parse("C*06:266") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_267N():
    result = parse("C*06:267N")
    assert result.__class__ is Allele, f'Expected parse("C*06:267N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:267N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_268():
    result = parse("C*06:268")
    assert result.__class__ is Allele, f'Expected parse("C*06:268") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_269():
    result = parse("C*06:269")
    assert result.__class__ is Allele, f'Expected parse("C*06:269") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_27():
    result = parse("C*06:27")
    assert result.__class__ is Allele, f'Expected parse("C*06:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_270():
    result = parse("C*06:270")
    assert result.__class__ is Allele, f'Expected parse("C*06:270") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_271():
    result = parse("C*06:271")
    assert result.__class__ is Allele, f'Expected parse("C*06:271") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_272():
    result = parse("C*06:272")
    assert result.__class__ is Allele, f'Expected parse("C*06:272") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_273():
    result = parse("C*06:273")
    assert result.__class__ is Allele, f'Expected parse("C*06:273") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_274():
    result = parse("C*06:274")
    assert result.__class__ is Allele, f'Expected parse("C*06:274") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_275():
    result = parse("C*06:275")
    assert result.__class__ is Allele, f'Expected parse("C*06:275") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_276():
    result = parse("C*06:276")
    assert result.__class__ is Allele, f'Expected parse("C*06:276") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_277():
    result = parse("C*06:277")
    assert result.__class__ is Allele, f'Expected parse("C*06:277") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_278():
    result = parse("C*06:278")
    assert result.__class__ is Allele, f'Expected parse("C*06:278") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_279():
    result = parse("C*06:279")
    assert result.__class__ is Allele, f'Expected parse("C*06:279") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_28():
    result = parse("C*06:28")
    assert result.__class__ is Allele, f'Expected parse("C*06:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_280():
    result = parse("C*06:280")
    assert result.__class__ is Allele, f'Expected parse("C*06:280") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_281N():
    result = parse("C*06:281N")
    assert result.__class__ is Allele, f'Expected parse("C*06:281N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:281N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_282():
    result = parse("C*06:282")
    assert result.__class__ is Allele, f'Expected parse("C*06:282") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_283():
    result = parse("C*06:283")
    assert result.__class__ is Allele, f'Expected parse("C*06:283") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_284():
    result = parse("C*06:284")
    assert result.__class__ is Allele, f'Expected parse("C*06:284") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_285Q():
    result = parse("C*06:285Q")
    assert result.__class__ is Allele, f'Expected parse("C*06:285Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:285Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_286():
    result = parse("C*06:286")
    assert result.__class__ is Allele, f'Expected parse("C*06:286") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_287():
    result = parse("C*06:287")
    assert result.__class__ is Allele, f'Expected parse("C*06:287") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:287") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_288():
    result = parse("C*06:288")
    assert result.__class__ is Allele, f'Expected parse("C*06:288") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_289():
    result = parse("C*06:289")
    assert result.__class__ is Allele, f'Expected parse("C*06:289") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_29():
    result = parse("C*06:29")
    assert result.__class__ is Allele, f'Expected parse("C*06:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_290():
    result = parse("C*06:290")
    assert result.__class__ is Allele, f'Expected parse("C*06:290") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_291():
    result = parse("C*06:291")
    assert result.__class__ is Allele, f'Expected parse("C*06:291") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_292():
    result = parse("C*06:292")
    assert result.__class__ is Allele, f'Expected parse("C*06:292") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_293():
    result = parse("C*06:293")
    assert result.__class__ is Allele, f'Expected parse("C*06:293") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_294():
    result = parse("C*06:294")
    assert result.__class__ is Allele, f'Expected parse("C*06:294") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_295():
    result = parse("C*06:295")
    assert result.__class__ is Allele, f'Expected parse("C*06:295") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_296():
    result = parse("C*06:296")
    assert result.__class__ is Allele, f'Expected parse("C*06:296") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_297():
    result = parse("C*06:297")
    assert result.__class__ is Allele, f'Expected parse("C*06:297") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_298():
    result = parse("C*06:298")
    assert result.__class__ is Allele, f'Expected parse("C*06:298") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_299():
    result = parse("C*06:299")
    assert result.__class__ is Allele, f'Expected parse("C*06:299") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_30():
    result = parse("C*06:30")
    assert result.__class__ is Allele, f'Expected parse("C*06:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_300():
    result = parse("C*06:300")
    assert result.__class__ is Allele, f'Expected parse("C*06:300") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_301N():
    result = parse("C*06:301N")
    assert result.__class__ is Allele, f'Expected parse("C*06:301N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:301N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_302():
    result = parse("C*06:302")
    assert result.__class__ is Allele, f'Expected parse("C*06:302") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_303():
    result = parse("C*06:303")
    assert result.__class__ is Allele, f'Expected parse("C*06:303") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:303") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_304():
    result = parse("C*06:304")
    assert result.__class__ is Allele, f'Expected parse("C*06:304") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:304") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_305():
    result = parse("C*06:305")
    assert result.__class__ is Allele, f'Expected parse("C*06:305") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_306():
    result = parse("C*06:306")
    assert result.__class__ is Allele, f'Expected parse("C*06:306") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:306") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_307():
    result = parse("C*06:307")
    assert result.__class__ is Allele, f'Expected parse("C*06:307") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_31():
    result = parse("C*06:31")
    assert result.__class__ is Allele, f'Expected parse("C*06:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_32():
    result = parse("C*06:32")
    assert result.__class__ is Allele, f'Expected parse("C*06:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_33():
    result = parse("C*06:33")
    assert result.__class__ is Allele, f'Expected parse("C*06:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_34_01():
    result = parse("C*06:34:01")
    assert result.__class__ is Allele, f'Expected parse("C*06:34:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:34:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_34_02():
    result = parse("C*06:34:02")
    assert result.__class__ is Allele, f'Expected parse("C*06:34:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:34:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_35():
    result = parse("C*06:35")
    assert result.__class__ is Allele, f'Expected parse("C*06:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_36():
    result = parse("C*06:36")
    assert result.__class__ is Allele, f'Expected parse("C*06:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_37():
    result = parse("C*06:37")
    assert result.__class__ is Allele, f'Expected parse("C*06:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_38():
    result = parse("C*06:38")
    assert result.__class__ is Allele, f'Expected parse("C*06:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_39():
    result = parse("C*06:39")
    assert result.__class__ is Allele, f'Expected parse("C*06:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_40():
    result = parse("C*06:40")
    assert result.__class__ is Allele, f'Expected parse("C*06:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_41():
    result = parse("C*06:41")
    assert result.__class__ is Allele, f'Expected parse("C*06:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_42_01():
    result = parse("C*06:42:01")
    assert result.__class__ is Allele, f'Expected parse("C*06:42:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:42:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_42_02():
    result = parse("C*06:42:02")
    assert result.__class__ is Allele, f'Expected parse("C*06:42:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:42:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_43_01():
    result = parse("C*06:43:01")
    assert result.__class__ is Allele, f'Expected parse("C*06:43:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:43:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_43_02():
    result = parse("C*06:43:02")
    assert result.__class__ is Allele, f'Expected parse("C*06:43:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:43:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_44():
    result = parse("C*06:44")
    assert result.__class__ is Allele, f'Expected parse("C*06:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_45():
    result = parse("C*06:45")
    assert result.__class__ is Allele, f'Expected parse("C*06:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_46N():
    result = parse("C*06:46N")
    assert result.__class__ is Allele, f'Expected parse("C*06:46N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:46N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_47():
    result = parse("C*06:47")
    assert result.__class__ is Allele, f'Expected parse("C*06:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_48():
    result = parse("C*06:48")
    assert result.__class__ is Allele, f'Expected parse("C*06:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_49N():
    result = parse("C*06:49N")
    assert result.__class__ is Allele, f'Expected parse("C*06:49N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:49N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_50():
    result = parse("C*06:50")
    assert result.__class__ is Allele, f'Expected parse("C*06:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_51():
    result = parse("C*06:51")
    assert result.__class__ is Allele, f'Expected parse("C*06:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_52():
    result = parse("C*06:52")
    assert result.__class__ is Allele, f'Expected parse("C*06:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_53_01():
    result = parse("C*06:53:01")
    assert result.__class__ is Allele, f'Expected parse("C*06:53:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:53:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_53_02():
    result = parse("C*06:53:02")
    assert result.__class__ is Allele, f'Expected parse("C*06:53:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:53:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_54():
    result = parse("C*06:54")
    assert result.__class__ is Allele, f'Expected parse("C*06:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_55():
    result = parse("C*06:55")
    assert result.__class__ is Allele, f'Expected parse("C*06:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_56():
    result = parse("C*06:56")
    assert result.__class__ is Allele, f'Expected parse("C*06:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_57():
    result = parse("C*06:57")
    assert result.__class__ is Allele, f'Expected parse("C*06:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_58():
    result = parse("C*06:58")
    assert result.__class__ is Allele, f'Expected parse("C*06:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_59():
    result = parse("C*06:59")
    assert result.__class__ is Allele, f'Expected parse("C*06:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_60():
    result = parse("C*06:60")
    assert result.__class__ is Allele, f'Expected parse("C*06:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_61():
    result = parse("C*06:61")
    assert result.__class__ is Allele, f'Expected parse("C*06:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_62():
    result = parse("C*06:62")
    assert result.__class__ is Allele, f'Expected parse("C*06:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_63():
    result = parse("C*06:63")
    assert result.__class__ is Allele, f'Expected parse("C*06:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_64():
    result = parse("C*06:64")
    assert result.__class__ is Allele, f'Expected parse("C*06:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_65():
    result = parse("C*06:65")
    assert result.__class__ is Allele, f'Expected parse("C*06:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_66():
    result = parse("C*06:66")
    assert result.__class__ is Allele, f'Expected parse("C*06:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_67():
    result = parse("C*06:67")
    assert result.__class__ is Allele, f'Expected parse("C*06:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_68():
    result = parse("C*06:68")
    assert result.__class__ is Allele, f'Expected parse("C*06:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_69():
    result = parse("C*06:69")
    assert result.__class__ is Allele, f'Expected parse("C*06:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_70_01():
    result = parse("C*06:70:01")
    assert result.__class__ is Allele, f'Expected parse("C*06:70:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:70:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_70_02():
    result = parse("C*06:70:02")
    assert result.__class__ is Allele, f'Expected parse("C*06:70:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:70:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_71():
    result = parse("C*06:71")
    assert result.__class__ is Allele, f'Expected parse("C*06:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_72():
    result = parse("C*06:72")
    assert result.__class__ is Allele, f'Expected parse("C*06:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_73():
    result = parse("C*06:73")
    assert result.__class__ is Allele, f'Expected parse("C*06:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_74Q():
    result = parse("C*06:74Q")
    assert result.__class__ is Allele, f'Expected parse("C*06:74Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:74Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_75():
    result = parse("C*06:75")
    assert result.__class__ is Allele, f'Expected parse("C*06:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_76_01():
    result = parse("C*06:76:01")
    assert result.__class__ is Allele, f'Expected parse("C*06:76:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:76:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_76_02():
    result = parse("C*06:76:02")
    assert result.__class__ is Allele, f'Expected parse("C*06:76:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*06:76:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_77():
    result = parse("C*06:77")
    assert result.__class__ is Allele, f'Expected parse("C*06:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_78():
    result = parse("C*06:78")
    assert result.__class__ is Allele, f'Expected parse("C*06:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_79N():
    result = parse("C*06:79N")
    assert result.__class__ is Allele, f'Expected parse("C*06:79N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:79N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_80():
    result = parse("C*06:80")
    assert result.__class__ is Allele, f'Expected parse("C*06:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_81():
    result = parse("C*06:81")
    assert result.__class__ is Allele, f'Expected parse("C*06:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_82():
    result = parse("C*06:82")
    assert result.__class__ is Allele, f'Expected parse("C*06:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_83():
    result = parse("C*06:83")
    assert result.__class__ is Allele, f'Expected parse("C*06:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_84():
    result = parse("C*06:84")
    assert result.__class__ is Allele, f'Expected parse("C*06:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_85():
    result = parse("C*06:85")
    assert result.__class__ is Allele, f'Expected parse("C*06:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_86():
    result = parse("C*06:86")
    assert result.__class__ is Allele, f'Expected parse("C*06:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_87():
    result = parse("C*06:87")
    assert result.__class__ is Allele, f'Expected parse("C*06:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_88():
    result = parse("C*06:88")
    assert result.__class__ is Allele, f'Expected parse("C*06:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_89():
    result = parse("C*06:89")
    assert result.__class__ is Allele, f'Expected parse("C*06:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_90():
    result = parse("C*06:90")
    assert result.__class__ is Allele, f'Expected parse("C*06:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_91():
    result = parse("C*06:91")
    assert result.__class__ is Allele, f'Expected parse("C*06:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_92():
    result = parse("C*06:92")
    assert result.__class__ is Allele, f'Expected parse("C*06:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_93():
    result = parse("C*06:93")
    assert result.__class__ is Allele, f'Expected parse("C*06:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_94():
    result = parse("C*06:94")
    assert result.__class__ is Allele, f'Expected parse("C*06:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_95():
    result = parse("C*06:95")
    assert result.__class__ is Allele, f'Expected parse("C*06:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_96():
    result = parse("C*06:96")
    assert result.__class__ is Allele, f'Expected parse("C*06:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_97():
    result = parse("C*06:97")
    assert result.__class__ is Allele, f'Expected parse("C*06:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_98():
    result = parse("C*06:98")
    assert result.__class__ is Allele, f'Expected parse("C*06:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_06_99():
    result = parse("C*06:99")
    assert result.__class__ is Allele, f'Expected parse("C*06:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*06:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_01():
    result = parse("C*07:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_02():
    result = parse("C*07:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_03():
    result = parse("C*07:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_04():
    result = parse("C*07:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_05():
    result = parse("C*07:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_06():
    result = parse("C*07:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_07():
    result = parse("C*07:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_08():
    result = parse("C*07:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_09():
    result = parse("C*07:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_10():
    result = parse("C*07:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_11():
    result = parse("C*07:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_12():
    result = parse("C*07:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_13():
    result = parse("C*07:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_14Q():
    result = parse("C*07:01:01:14Q")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:14Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:14Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_15():
    result = parse("C*07:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_16():
    result = parse("C*07:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_17():
    result = parse("C*07:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_18():
    result = parse("C*07:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_19():
    result = parse("C*07:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_20():
    result = parse("C*07:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_21():
    result = parse("C*07:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_22():
    result = parse("C*07:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_23():
    result = parse("C*07:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_24():
    result = parse("C*07:01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_25():
    result = parse("C*07:01:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_26():
    result = parse("C*07:01:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_27():
    result = parse("C*07:01:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_28():
    result = parse("C*07:01:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_29():
    result = parse("C*07:01:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_30():
    result = parse("C*07:01:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_31():
    result = parse("C*07:01:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_32():
    result = parse("C*07:01:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_33():
    result = parse("C*07:01:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_34():
    result = parse("C*07:01:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_35():
    result = parse("C*07:01:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_36():
    result = parse("C*07:01:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_37():
    result = parse("C*07:01:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_38():
    result = parse("C*07:01:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_39():
    result = parse("C*07:01:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_40():
    result = parse("C*07:01:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_41():
    result = parse("C*07:01:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_42():
    result = parse("C*07:01:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_43():
    result = parse("C*07:01:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_44():
    result = parse("C*07:01:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_45():
    result = parse("C*07:01:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:45") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_46():
    result = parse("C*07:01:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:46") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_47():
    result = parse("C*07:01:01:47")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:47") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_48():
    result = parse("C*07:01:01:48")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:48") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:48") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_49():
    result = parse("C*07:01:01:49")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:49") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:49") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_50():
    result = parse("C*07:01:01:50")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:50") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:50") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_51():
    result = parse("C*07:01:01:51")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:51") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:51") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_52():
    result = parse("C*07:01:01:52")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:52") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:52") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_53():
    result = parse("C*07:01:01:53")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:53") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:53") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_54():
    result = parse("C*07:01:01:54")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:54") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:54") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_55():
    result = parse("C*07:01:01:55")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:55") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:55") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_56():
    result = parse("C*07:01:01:56")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:56") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:56") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_57():
    result = parse("C*07:01:01:57")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:57") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:57") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_58():
    result = parse("C*07:01:01:58")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:58") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:58") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_59():
    result = parse("C*07:01:01:59")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:59") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:59") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_60():
    result = parse("C*07:01:01:60")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:60") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:60") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_61():
    result = parse("C*07:01:01:61")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:61") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:61") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_62():
    result = parse("C*07:01:01:62")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:62") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:62") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_63():
    result = parse("C*07:01:01:63")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:63") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:63") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_64():
    result = parse("C*07:01:01:64")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:64") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:64") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_65():
    result = parse("C*07:01:01:65")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:65") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:65") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_66():
    result = parse("C*07:01:01:66")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:66") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:66") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_67():
    result = parse("C*07:01:01:67")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:67") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:67") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_68():
    result = parse("C*07:01:01:68")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:68") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:68") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_69():
    result = parse("C*07:01:01:69")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:69") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:69") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_70():
    result = parse("C*07:01:01:70")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:70") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:70") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_71():
    result = parse("C*07:01:01:71")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:71") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:71") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_72():
    result = parse("C*07:01:01:72")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:72") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:72") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_73():
    result = parse("C*07:01:01:73")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:73") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:73") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_74():
    result = parse("C*07:01:01:74")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:74") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:74") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_75():
    result = parse("C*07:01:01:75")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:75") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:75") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_76():
    result = parse("C*07:01:01:76")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:76") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:76") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_77():
    result = parse("C*07:01:01:77")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:77") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:77") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_78():
    result = parse("C*07:01:01:78")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:78") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:78") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_79():
    result = parse("C*07:01:01:79")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:79") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:79") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_80():
    result = parse("C*07:01:01:80")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:80") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:80") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_81():
    result = parse("C*07:01:01:81")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:81") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:81") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_82():
    result = parse("C*07:01:01:82")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:82") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:82") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_83():
    result = parse("C*07:01:01:83")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:83") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:83") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_84():
    result = parse("C*07:01:01:84")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:84") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:84") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_85():
    result = parse("C*07:01:01:85")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:85") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:85") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_86():
    result = parse("C*07:01:01:86")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:86") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:86") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_87():
    result = parse("C*07:01:01:87")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:87") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:87") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_01_88():
    result = parse("C*07:01:01:88")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:01:88") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:01:88") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_02_01():
    result = parse("C*07:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_02_02():
    result = parse("C*07:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_02_03():
    result = parse("C*07:01:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_02_04():
    result = parse("C*07:01:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_02_05():
    result = parse("C*07:01:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_02_06():
    result = parse("C*07:01:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:02:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_02_07():
    result = parse("C*07:01:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:02:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_02_08():
    result = parse("C*07:01:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:01:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:01:02:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_04():
    result = parse("C*07:01:04")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_05():
    result = parse("C*07:01:05")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_06():
    result = parse("C*07:01:06")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_07():
    result = parse("C*07:01:07")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_08():
    result = parse("C*07:01:08")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_09():
    result = parse("C*07:01:09")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_10():
    result = parse("C*07:01:10")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_11():
    result = parse("C*07:01:11")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_12():
    result = parse("C*07:01:12")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_13():
    result = parse("C*07:01:13")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_14():
    result = parse("C*07:01:14")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_15():
    result = parse("C*07:01:15")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_16():
    result = parse("C*07:01:16")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_17():
    result = parse("C*07:01:17")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_18():
    result = parse("C*07:01:18")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_19():
    result = parse("C*07:01:19")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_20():
    result = parse("C*07:01:20")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_21():
    result = parse("C*07:01:21")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_22():
    result = parse("C*07:01:22")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_23():
    result = parse("C*07:01:23")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_24():
    result = parse("C*07:01:24")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_25():
    result = parse("C*07:01:25")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_26():
    result = parse("C*07:01:26")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_27():
    result = parse("C*07:01:27")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_28():
    result = parse("C*07:01:28")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_29():
    result = parse("C*07:01:29")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_30():
    result = parse("C*07:01:30")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_31():
    result = parse("C*07:01:31")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_32():
    result = parse("C*07:01:32")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_33():
    result = parse("C*07:01:33")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_34():
    result = parse("C*07:01:34")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_35():
    result = parse("C*07:01:35")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_36():
    result = parse("C*07:01:36")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_37():
    result = parse("C*07:01:37")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_38():
    result = parse("C*07:01:38")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_39():
    result = parse("C*07:01:39")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_40():
    result = parse("C*07:01:40")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_41():
    result = parse("C*07:01:41")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_42():
    result = parse("C*07:01:42")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_43():
    result = parse("C*07:01:43")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_44():
    result = parse("C*07:01:44")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_45():
    result = parse("C*07:01:45")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_46():
    result = parse("C*07:01:46")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_47():
    result = parse("C*07:01:47")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_48():
    result = parse("C*07:01:48")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_49():
    result = parse("C*07:01:49")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_50():
    result = parse("C*07:01:50")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_51():
    result = parse("C*07:01:51")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_52():
    result = parse("C*07:01:52")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_53():
    result = parse("C*07:01:53")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_54():
    result = parse("C*07:01:54")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_55():
    result = parse("C*07:01:55")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_56():
    result = parse("C*07:01:56")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_57():
    result = parse("C*07:01:57")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_58():
    result = parse("C*07:01:58")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_59():
    result = parse("C*07:01:59")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_60():
    result = parse("C*07:01:60")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_61():
    result = parse("C*07:01:61")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_62():
    result = parse("C*07:01:62")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_63():
    result = parse("C*07:01:63")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_64():
    result = parse("C*07:01:64")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_65():
    result = parse("C*07:01:65")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_66():
    result = parse("C*07:01:66")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:66") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:66") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_67():
    result = parse("C*07:01:67")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:67") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:67") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_68():
    result = parse("C*07:01:68")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:68") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:68") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_69():
    result = parse("C*07:01:69")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:69") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:69") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_70():
    result = parse("C*07:01:70")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:70") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:70") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_71():
    result = parse("C*07:01:71")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:71") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:71") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_72():
    result = parse("C*07:01:72")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:72") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:72") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_73():
    result = parse("C*07:01:73")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:73") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:73") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_74():
    result = parse("C*07:01:74")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:74") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:74") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_75():
    result = parse("C*07:01:75")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:75") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:75") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_76():
    result = parse("C*07:01:76")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:76") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:76") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_77():
    result = parse("C*07:01:77")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:77") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:77") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_78():
    result = parse("C*07:01:78")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:78") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:78") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_79():
    result = parse("C*07:01:79")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:79") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:79") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_80():
    result = parse("C*07:01:80")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:80") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:80") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_81():
    result = parse("C*07:01:81")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:81") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:81") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_82():
    result = parse("C*07:01:82")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:82") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:82") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_83():
    result = parse("C*07:01:83")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:83") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:83") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_84():
    result = parse("C*07:01:84")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:84") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:84") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_85():
    result = parse("C*07:01:85")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:85") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:85") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_86():
    result = parse("C*07:01:86")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:86") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:86") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_87():
    result = parse("C*07:01:87")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:87") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:87") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_88():
    result = parse("C*07:01:88")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:88") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:88") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_89():
    result = parse("C*07:01:89")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:89") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:89") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_90():
    result = parse("C*07:01:90")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:90") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:90") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_91():
    result = parse("C*07:01:91")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:91") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:91") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_92():
    result = parse("C*07:01:92")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:92") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:92") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_93():
    result = parse("C*07:01:93")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:93") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:93") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_01_94():
    result = parse("C*07:01:94")
    assert result.__class__ is Allele, f'Expected parse("C*07:01:94") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:01:94") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_01():
    result = parse("C*07:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_02():
    result = parse("C*07:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_03():
    result = parse("C*07:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_04():
    result = parse("C*07:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_05():
    result = parse("C*07:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_06():
    result = parse("C*07:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_07():
    result = parse("C*07:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_08():
    result = parse("C*07:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_09():
    result = parse("C*07:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_10():
    result = parse("C*07:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_100():
    result = parse("C*07:02:01:100")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:100") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_101():
    result = parse("C*07:02:01:101")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:101") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_102():
    result = parse("C*07:02:01:102")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:102") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_103():
    result = parse("C*07:02:01:103")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:103") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_104():
    result = parse("C*07:02:01:104")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:104") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_105():
    result = parse("C*07:02:01:105")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:105") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_106():
    result = parse("C*07:02:01:106")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:106") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_107():
    result = parse("C*07:02:01:107")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:107") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_108():
    result = parse("C*07:02:01:108")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:108") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_109():
    result = parse("C*07:02:01:109")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:109") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_11():
    result = parse("C*07:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_110():
    result = parse("C*07:02:01:110")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:110") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_12():
    result = parse("C*07:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_13():
    result = parse("C*07:02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_14():
    result = parse("C*07:02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_15():
    result = parse("C*07:02:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_16():
    result = parse("C*07:02:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_17N():
    result = parse("C*07:02:01:17N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:17N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:17N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_18():
    result = parse("C*07:02:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_19():
    result = parse("C*07:02:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_20():
    result = parse("C*07:02:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_21():
    result = parse("C*07:02:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_22():
    result = parse("C*07:02:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_23():
    result = parse("C*07:02:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_24():
    result = parse("C*07:02:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_25():
    result = parse("C*07:02:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_26():
    result = parse("C*07:02:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_27():
    result = parse("C*07:02:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_28():
    result = parse("C*07:02:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_29():
    result = parse("C*07:02:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_30():
    result = parse("C*07:02:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_31():
    result = parse("C*07:02:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_32():
    result = parse("C*07:02:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_33():
    result = parse("C*07:02:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_34():
    result = parse("C*07:02:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_35():
    result = parse("C*07:02:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_36():
    result = parse("C*07:02:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_37():
    result = parse("C*07:02:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_38():
    result = parse("C*07:02:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_39():
    result = parse("C*07:02:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_40():
    result = parse("C*07:02:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_41():
    result = parse("C*07:02:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_42():
    result = parse("C*07:02:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_43():
    result = parse("C*07:02:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_44():
    result = parse("C*07:02:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_45():
    result = parse("C*07:02:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:45") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_46():
    result = parse("C*07:02:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:46") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_47():
    result = parse("C*07:02:01:47")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:47") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_48():
    result = parse("C*07:02:01:48")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:48") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:48") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_49():
    result = parse("C*07:02:01:49")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:49") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:49") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_50():
    result = parse("C*07:02:01:50")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:50") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:50") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_51():
    result = parse("C*07:02:01:51")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:51") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:51") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_52():
    result = parse("C*07:02:01:52")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:52") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:52") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_53():
    result = parse("C*07:02:01:53")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:53") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:53") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_54():
    result = parse("C*07:02:01:54")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:54") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:54") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_55():
    result = parse("C*07:02:01:55")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:55") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:55") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_56():
    result = parse("C*07:02:01:56")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:56") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:56") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_57():
    result = parse("C*07:02:01:57")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:57") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:57") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_58():
    result = parse("C*07:02:01:58")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:58") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:58") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_59():
    result = parse("C*07:02:01:59")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:59") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:59") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_60():
    result = parse("C*07:02:01:60")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:60") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:60") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_61():
    result = parse("C*07:02:01:61")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:61") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:61") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_62():
    result = parse("C*07:02:01:62")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:62") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:62") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_63():
    result = parse("C*07:02:01:63")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:63") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:63") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_64():
    result = parse("C*07:02:01:64")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:64") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:64") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_65():
    result = parse("C*07:02:01:65")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:65") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:65") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_66():
    result = parse("C*07:02:01:66")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:66") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:66") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_67():
    result = parse("C*07:02:01:67")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:67") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:67") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_68():
    result = parse("C*07:02:01:68")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:68") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:68") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_69():
    result = parse("C*07:02:01:69")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:69") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:69") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_70():
    result = parse("C*07:02:01:70")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:70") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:70") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_71():
    result = parse("C*07:02:01:71")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:71") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:71") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_72():
    result = parse("C*07:02:01:72")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:72") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:72") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_73():
    result = parse("C*07:02:01:73")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:73") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:73") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_74Q():
    result = parse("C*07:02:01:74Q")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:74Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:74Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_75():
    result = parse("C*07:02:01:75")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:75") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:75") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_76():
    result = parse("C*07:02:01:76")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:76") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:76") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_77():
    result = parse("C*07:02:01:77")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:77") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:77") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_78():
    result = parse("C*07:02:01:78")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:78") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:78") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_79():
    result = parse("C*07:02:01:79")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:79") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:79") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_80():
    result = parse("C*07:02:01:80")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:80") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:80") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_81():
    result = parse("C*07:02:01:81")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:81") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:81") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_82():
    result = parse("C*07:02:01:82")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:82") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:82") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_83():
    result = parse("C*07:02:01:83")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:83") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:83") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_84():
    result = parse("C*07:02:01:84")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:84") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:84") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_85():
    result = parse("C*07:02:01:85")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:85") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:85") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_86():
    result = parse("C*07:02:01:86")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:86") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:86") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_87():
    result = parse("C*07:02:01:87")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:87") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:87") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_88():
    result = parse("C*07:02:01:88")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:88") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:88") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_89():
    result = parse("C*07:02:01:89")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:89") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:89") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_90():
    result = parse("C*07:02:01:90")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:90") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:90") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_91():
    result = parse("C*07:02:01:91")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:91") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:91") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_92():
    result = parse("C*07:02:01:92")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:92") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:92") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_93():
    result = parse("C*07:02:01:93")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:93") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:93") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_94():
    result = parse("C*07:02:01:94")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:94") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:94") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_95():
    result = parse("C*07:02:01:95")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:95") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:95") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_96():
    result = parse("C*07:02:01:96")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:96") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:96") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_97():
    result = parse("C*07:02:01:97")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:97") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:97") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_98():
    result = parse("C*07:02:01:98")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:98") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:98") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_01_99():
    result = parse("C*07:02:01:99")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:01:99") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:01:99") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_02():
    result = parse("C*07:02:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_03():
    result = parse("C*07:02:03")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_04():
    result = parse("C*07:02:04")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_05():
    result = parse("C*07:02:05")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_06():
    result = parse("C*07:02:06")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_07():
    result = parse("C*07:02:07")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_08():
    result = parse("C*07:02:08")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_09():
    result = parse("C*07:02:09")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_10():
    result = parse("C*07:02:10")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_100():
    result = parse("C*07:02:100")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:100") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_101():
    result = parse("C*07:02:101")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:101") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_102():
    result = parse("C*07:02:102")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:102") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_103():
    result = parse("C*07:02:103")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:103") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_104_01():
    result = parse("C*07:02:104:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:104:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:104:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_104_02():
    result = parse("C*07:02:104:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:104:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:104:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_105():
    result = parse("C*07:02:105")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:105") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_106_01():
    result = parse("C*07:02:106:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:106:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:106:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_106_02():
    result = parse("C*07:02:106:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:106:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:02:106:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_107():
    result = parse("C*07:02:107")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:107") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_108():
    result = parse("C*07:02:108")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:108") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_109():
    result = parse("C*07:02:109")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:109") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_11():
    result = parse("C*07:02:11")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_110():
    result = parse("C*07:02:110")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:110") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_111():
    result = parse("C*07:02:111")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:111") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_112():
    result = parse("C*07:02:112")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:112") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_113():
    result = parse("C*07:02:113")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:113") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_114():
    result = parse("C*07:02:114")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:114") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_115():
    result = parse("C*07:02:115")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:115") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:115") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_116():
    result = parse("C*07:02:116")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:116") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_117():
    result = parse("C*07:02:117")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:117") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_118():
    result = parse("C*07:02:118")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:118") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:118") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_119():
    result = parse("C*07:02:119")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:119") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:119") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_12():
    result = parse("C*07:02:12")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_120():
    result = parse("C*07:02:120")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:120") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:120") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_121():
    result = parse("C*07:02:121")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:02:121") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:121") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_13():
    result = parse("C*07:02:13")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_14():
    result = parse("C*07:02:14")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_15():
    result = parse("C*07:02:15")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_16():
    result = parse("C*07:02:16")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_17():
    result = parse("C*07:02:17")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_18():
    result = parse("C*07:02:18")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_19():
    result = parse("C*07:02:19")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_20():
    result = parse("C*07:02:20")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_21():
    result = parse("C*07:02:21")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_22():
    result = parse("C*07:02:22")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_23():
    result = parse("C*07:02:23")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_24():
    result = parse("C*07:02:24")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_25():
    result = parse("C*07:02:25")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_26():
    result = parse("C*07:02:26")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_27():
    result = parse("C*07:02:27")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_28():
    result = parse("C*07:02:28")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_29():
    result = parse("C*07:02:29")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_30():
    result = parse("C*07:02:30")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_31():
    result = parse("C*07:02:31")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_32():
    result = parse("C*07:02:32")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_33():
    result = parse("C*07:02:33")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_34():
    result = parse("C*07:02:34")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_35():
    result = parse("C*07:02:35")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_36():
    result = parse("C*07:02:36")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_37():
    result = parse("C*07:02:37")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_38():
    result = parse("C*07:02:38")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_39():
    result = parse("C*07:02:39")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_40():
    result = parse("C*07:02:40")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_41():
    result = parse("C*07:02:41")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_42():
    result = parse("C*07:02:42")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_43():
    result = parse("C*07:02:43")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_44():
    result = parse("C*07:02:44")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_45():
    result = parse("C*07:02:45")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_46():
    result = parse("C*07:02:46")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_47():
    result = parse("C*07:02:47")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_48():
    result = parse("C*07:02:48")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_49():
    result = parse("C*07:02:49")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_50():
    result = parse("C*07:02:50")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_51():
    result = parse("C*07:02:51")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_52():
    result = parse("C*07:02:52")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_53():
    result = parse("C*07:02:53")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_54():
    result = parse("C*07:02:54")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_55():
    result = parse("C*07:02:55")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_56():
    result = parse("C*07:02:56")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_57():
    result = parse("C*07:02:57")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_58():
    result = parse("C*07:02:58")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_59():
    result = parse("C*07:02:59")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_60():
    result = parse("C*07:02:60")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_61():
    result = parse("C*07:02:61")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_62():
    result = parse("C*07:02:62")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_63():
    result = parse("C*07:02:63")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_64():
    result = parse("C*07:02:64")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_65():
    result = parse("C*07:02:65")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_66():
    result = parse("C*07:02:66")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:66") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:66") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_67():
    result = parse("C*07:02:67")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:67") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:67") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_68():
    result = parse("C*07:02:68")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:68") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:68") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_69():
    result = parse("C*07:02:69")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:69") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:69") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_70():
    result = parse("C*07:02:70")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:70") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:70") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_71():
    result = parse("C*07:02:71")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:71") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:71") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_72():
    result = parse("C*07:02:72")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:72") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:72") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_73():
    result = parse("C*07:02:73")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:73") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:73") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_74():
    result = parse("C*07:02:74")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:74") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:74") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_75():
    result = parse("C*07:02:75")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:75") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:75") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_76():
    result = parse("C*07:02:76")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:76") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:76") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_77():
    result = parse("C*07:02:77")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:77") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:77") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_78():
    result = parse("C*07:02:78")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:78") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:78") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_79():
    result = parse("C*07:02:79")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:79") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:79") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_80():
    result = parse("C*07:02:80")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:80") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:80") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_81():
    result = parse("C*07:02:81")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:81") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:81") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_82():
    result = parse("C*07:02:82")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:82") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:82") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_83():
    result = parse("C*07:02:83")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:83") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:83") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_84():
    result = parse("C*07:02:84")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:84") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:84") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_85():
    result = parse("C*07:02:85")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:85") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:85") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_86():
    result = parse("C*07:02:86")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:86") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:86") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_87():
    result = parse("C*07:02:87")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:87") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:87") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_88():
    result = parse("C*07:02:88")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:88") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:88") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_89():
    result = parse("C*07:02:89")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:89") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:89") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_90():
    result = parse("C*07:02:90")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:90") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:90") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_91():
    result = parse("C*07:02:91")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:91") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:91") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_92():
    result = parse("C*07:02:92")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:92") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:92") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_93():
    result = parse("C*07:02:93")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:93") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:93") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_94():
    result = parse("C*07:02:94")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:94") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:94") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_95():
    result = parse("C*07:02:95")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:95") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:95") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_96():
    result = parse("C*07:02:96")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:96") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:96") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_97():
    result = parse("C*07:02:97")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:97") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:97") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_98():
    result = parse("C*07:02:98")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:98") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:98") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_02_99():
    result = parse("C*07:02:99")
    assert result.__class__ is Allele, f'Expected parse("C*07:02:99") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:02:99") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_03():
    result = parse("C*07:03")
    assert result.__class__ is Allele, f'Expected parse("C*07:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_01_01():
    result = parse("C*07:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_01_02():
    result = parse("C*07:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_01_03():
    result = parse("C*07:04:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:04:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:04:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_01_04():
    result = parse("C*07:04:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:04:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:04:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_01_05():
    result = parse("C*07:04:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:04:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:04:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_01_06():
    result = parse("C*07:04:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:04:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:04:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_01_07():
    result = parse("C*07:04:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:04:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:04:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_01_08():
    result = parse("C*07:04:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:04:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:04:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_01_09():
    result = parse("C*07:04:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:04:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:04:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_01_10():
    result = parse("C*07:04:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:04:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:04:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_01_11():
    result = parse("C*07:04:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:04:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:04:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_01_12():
    result = parse("C*07:04:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:04:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:04:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_01_13():
    result = parse("C*07:04:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:04:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:04:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_02_01():
    result = parse("C*07:04:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:04:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:04:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_02_02():
    result = parse("C*07:04:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:04:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:04:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_03():
    result = parse("C*07:04:03")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_04():
    result = parse("C*07:04:04")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_05():
    result = parse("C*07:04:05")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_06():
    result = parse("C*07:04:06")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_07():
    result = parse("C*07:04:07")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_08():
    result = parse("C*07:04:08")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_09():
    result = parse("C*07:04:09")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_10():
    result = parse("C*07:04:10")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_11():
    result = parse("C*07:04:11")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_12():
    result = parse("C*07:04:12")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_13():
    result = parse("C*07:04:13")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_14():
    result = parse("C*07:04:14")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_15():
    result = parse("C*07:04:15")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_16():
    result = parse("C*07:04:16")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_17():
    result = parse("C*07:04:17")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_18():
    result = parse("C*07:04:18")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_19():
    result = parse("C*07:04:19")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_20():
    result = parse("C*07:04:20")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_21():
    result = parse("C*07:04:21")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_22():
    result = parse("C*07:04:22")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_04_23():
    result = parse("C*07:04:23")
    assert result.__class__ is Allele, f'Expected parse("C*07:04:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:04:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_05():
    result = parse("C*07:05")
    assert result.__class__ is Allele, f'Expected parse("C*07:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_06_01_01():
    result = parse("C*07:06:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:06:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:06:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_06_01_02():
    result = parse("C*07:06:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:06:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:06:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_06_01_03():
    result = parse("C*07:06:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:06:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:06:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_06_01_04():
    result = parse("C*07:06:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:06:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:06:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_06_01_05Q():
    result = parse("C*07:06:01:05Q")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:06:01:05Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:06:01:05Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_06_01_06():
    result = parse("C*07:06:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:06:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:06:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_06_01_07():
    result = parse("C*07:06:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:06:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:06:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_06_01_08():
    result = parse("C*07:06:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:06:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:06:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_06_02():
    result = parse("C*07:06:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:06:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_06_03():
    result = parse("C*07:06:03")
    assert result.__class__ is Allele, f'Expected parse("C*07:06:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:06:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_06_04():
    result = parse("C*07:06:04")
    assert result.__class__ is Allele, f'Expected parse("C*07:06:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:06:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_07():
    result = parse("C*07:07")
    assert result.__class__ is Allele, f'Expected parse("C*07:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_08():
    result = parse("C*07:08")
    assert result.__class__ is Allele, f'Expected parse("C*07:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_09():
    result = parse("C*07:09")
    assert result.__class__ is Allele, f'Expected parse("C*07:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_10():
    result = parse("C*07:10")
    assert result.__class__ is Allele, f'Expected parse("C*07:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_100():
    result = parse("C*07:100")
    assert result.__class__ is Allele, f'Expected parse("C*07:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_101():
    result = parse("C*07:101")
    assert result.__class__ is Allele, f'Expected parse("C*07:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_102():
    result = parse("C*07:102")
    assert result.__class__ is Allele, f'Expected parse("C*07:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_103():
    result = parse("C*07:103")
    assert result.__class__ is Allele, f'Expected parse("C*07:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_104N():
    result = parse("C*07:104N")
    assert result.__class__ is Allele, f'Expected parse("C*07:104N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:104N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_105():
    result = parse("C*07:105")
    assert result.__class__ is Allele, f'Expected parse("C*07:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_106():
    result = parse("C*07:106")
    assert result.__class__ is Allele, f'Expected parse("C*07:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_107():
    result = parse("C*07:107")
    assert result.__class__ is Allele, f'Expected parse("C*07:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_108_01():
    result = parse("C*07:108:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:108:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:108:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_108_02():
    result = parse("C*07:108:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:108:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:108:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_109_01():
    result = parse("C*07:109:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:109:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:109:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_109_02():
    result = parse("C*07:109:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:109:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:109:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_11():
    result = parse("C*07:11")
    assert result.__class__ is Allele, f'Expected parse("C*07:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_110():
    result = parse("C*07:110")
    assert result.__class__ is Allele, f'Expected parse("C*07:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_111():
    result = parse("C*07:111")
    assert result.__class__ is Allele, f'Expected parse("C*07:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_112():
    result = parse("C*07:112")
    assert result.__class__ is Allele, f'Expected parse("C*07:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_113():
    result = parse("C*07:113")
    assert result.__class__ is Allele, f'Expected parse("C*07:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_114():
    result = parse("C*07:114")
    assert result.__class__ is Allele, f'Expected parse("C*07:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_115():
    result = parse("C*07:115")
    assert result.__class__ is Allele, f'Expected parse("C*07:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_116():
    result = parse("C*07:116")
    assert result.__class__ is Allele, f'Expected parse("C*07:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_117():
    result = parse("C*07:117")
    assert result.__class__ is Allele, f'Expected parse("C*07:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_118():
    result = parse("C*07:118")
    assert result.__class__ is Allele, f'Expected parse("C*07:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_119():
    result = parse("C*07:119")
    assert result.__class__ is Allele, f'Expected parse("C*07:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_12():
    result = parse("C*07:12")
    assert result.__class__ is Allele, f'Expected parse("C*07:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_120():
    result = parse("C*07:120")
    assert result.__class__ is Allele, f'Expected parse("C*07:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_121Q():
    result = parse("C*07:121Q")
    assert result.__class__ is Allele, f'Expected parse("C*07:121Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:121Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_122():
    result = parse("C*07:122")
    assert result.__class__ is Allele, f'Expected parse("C*07:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_123():
    result = parse("C*07:123")
    assert result.__class__ is Allele, f'Expected parse("C*07:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_124():
    result = parse("C*07:124")
    assert result.__class__ is Allele, f'Expected parse("C*07:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_125():
    result = parse("C*07:125")
    assert result.__class__ is Allele, f'Expected parse("C*07:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_126():
    result = parse("C*07:126")
    assert result.__class__ is Allele, f'Expected parse("C*07:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_127_01():
    result = parse("C*07:127:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:127:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:127:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_127_02():
    result = parse("C*07:127:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:127:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:127:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_128():
    result = parse("C*07:128")
    assert result.__class__ is Allele, f'Expected parse("C*07:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_129():
    result = parse("C*07:129")
    assert result.__class__ is Allele, f'Expected parse("C*07:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_130():
    result = parse("C*07:130")
    assert result.__class__ is Allele, f'Expected parse("C*07:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_131_01():
    result = parse("C*07:131:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:131:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:131:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_131_02():
    result = parse("C*07:131:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:131:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:131:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_132():
    result = parse("C*07:132")
    assert result.__class__ is Allele, f'Expected parse("C*07:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_133_01():
    result = parse("C*07:133:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:133:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:133:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_133_02():
    result = parse("C*07:133:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:133:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:133:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_134():
    result = parse("C*07:134")
    assert result.__class__ is Allele, f'Expected parse("C*07:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_135():
    result = parse("C*07:135")
    assert result.__class__ is Allele, f'Expected parse("C*07:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_136():
    result = parse("C*07:136")
    assert result.__class__ is Allele, f'Expected parse("C*07:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_137_01():
    result = parse("C*07:137:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:137:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:137:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_137_02():
    result = parse("C*07:137:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:137:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:137:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_138():
    result = parse("C*07:138")
    assert result.__class__ is Allele, f'Expected parse("C*07:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_139():
    result = parse("C*07:139")
    assert result.__class__ is Allele, f'Expected parse("C*07:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_13_01_01():
    result = parse("C*07:13:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:13:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:13:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_13_01_02():
    result = parse("C*07:13:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:13:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:13:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_14():
    result = parse("C*07:14")
    assert result.__class__ is Allele, f'Expected parse("C*07:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_140_01():
    result = parse("C*07:140:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:140:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:140:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_140_02():
    result = parse("C*07:140:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:140:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:140:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_141_01():
    result = parse("C*07:141:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:141:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:141:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_141_02():
    result = parse("C*07:141:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:141:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:141:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_142():
    result = parse("C*07:142")
    assert result.__class__ is Allele, f'Expected parse("C*07:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_143():
    result = parse("C*07:143")
    assert result.__class__ is Allele, f'Expected parse("C*07:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_144():
    result = parse("C*07:144")
    assert result.__class__ is Allele, f'Expected parse("C*07:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_145():
    result = parse("C*07:145")
    assert result.__class__ is Allele, f'Expected parse("C*07:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_146():
    result = parse("C*07:146")
    assert result.__class__ is Allele, f'Expected parse("C*07:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_147():
    result = parse("C*07:147")
    assert result.__class__ is Allele, f'Expected parse("C*07:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_148():
    result = parse("C*07:148")
    assert result.__class__ is Allele, f'Expected parse("C*07:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_149():
    result = parse("C*07:149")
    assert result.__class__ is Allele, f'Expected parse("C*07:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_15():
    result = parse("C*07:15")
    assert result.__class__ is Allele, f'Expected parse("C*07:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_150Q():
    result = parse("C*07:150Q")
    assert result.__class__ is Allele, f'Expected parse("C*07:150Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:150Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_151():
    result = parse("C*07:151")
    assert result.__class__ is Allele, f'Expected parse("C*07:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_152N():
    result = parse("C*07:152N")
    assert result.__class__ is Allele, f'Expected parse("C*07:152N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:152N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_153():
    result = parse("C*07:153")
    assert result.__class__ is Allele, f'Expected parse("C*07:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_154():
    result = parse("C*07:154")
    assert result.__class__ is Allele, f'Expected parse("C*07:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_155():
    result = parse("C*07:155")
    assert result.__class__ is Allele, f'Expected parse("C*07:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_156():
    result = parse("C*07:156")
    assert result.__class__ is Allele, f'Expected parse("C*07:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_157():
    result = parse("C*07:157")
    assert result.__class__ is Allele, f'Expected parse("C*07:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_158():
    result = parse("C*07:158")
    assert result.__class__ is Allele, f'Expected parse("C*07:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_159():
    result = parse("C*07:159")
    assert result.__class__ is Allele, f'Expected parse("C*07:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_16():
    result = parse("C*07:16")
    assert result.__class__ is Allele, f'Expected parse("C*07:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_160():
    result = parse("C*07:160")
    assert result.__class__ is Allele, f'Expected parse("C*07:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_161():
    result = parse("C*07:161")
    assert result.__class__ is Allele, f'Expected parse("C*07:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_162():
    result = parse("C*07:162")
    assert result.__class__ is Allele, f'Expected parse("C*07:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_163():
    result = parse("C*07:163")
    assert result.__class__ is Allele, f'Expected parse("C*07:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_164N():
    result = parse("C*07:164N")
    assert result.__class__ is Allele, f'Expected parse("C*07:164N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:164N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_165():
    result = parse("C*07:165")
    assert result.__class__ is Allele, f'Expected parse("C*07:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_166():
    result = parse("C*07:166")
    assert result.__class__ is Allele, f'Expected parse("C*07:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_167():
    result = parse("C*07:167")
    assert result.__class__ is Allele, f'Expected parse("C*07:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_168():
    result = parse("C*07:168")
    assert result.__class__ is Allele, f'Expected parse("C*07:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_169():
    result = parse("C*07:169")
    assert result.__class__ is Allele, f'Expected parse("C*07:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_170():
    result = parse("C*07:170")
    assert result.__class__ is Allele, f'Expected parse("C*07:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_171():
    result = parse("C*07:171")
    assert result.__class__ is Allele, f'Expected parse("C*07:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_172_01():
    result = parse("C*07:172:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:172:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:172:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_172_02():
    result = parse("C*07:172:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:172:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:172:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_173():
    result = parse("C*07:173")
    assert result.__class__ is Allele, f'Expected parse("C*07:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_174():
    result = parse("C*07:174")
    assert result.__class__ is Allele, f'Expected parse("C*07:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_175():
    result = parse("C*07:175")
    assert result.__class__ is Allele, f'Expected parse("C*07:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_176():
    result = parse("C*07:176")
    assert result.__class__ is Allele, f'Expected parse("C*07:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_177():
    result = parse("C*07:177")
    assert result.__class__ is Allele, f'Expected parse("C*07:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_178():
    result = parse("C*07:178")
    assert result.__class__ is Allele, f'Expected parse("C*07:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_179():
    result = parse("C*07:179")
    assert result.__class__ is Allele, f'Expected parse("C*07:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_17_01_01():
    result = parse("C*07:17:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:17:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:17:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_17_01_02():
    result = parse("C*07:17:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:17:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:17:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_17_02():
    result = parse("C*07:17:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:17:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:17:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_17_03():
    result = parse("C*07:17:03")
    assert result.__class__ is Allele, f'Expected parse("C*07:17:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:17:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_17_04():
    result = parse("C*07:17:04")
    assert result.__class__ is Allele, f'Expected parse("C*07:17:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:17:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_180():
    result = parse("C*07:180")
    assert result.__class__ is Allele, f'Expected parse("C*07:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_181():
    result = parse("C*07:181")
    assert result.__class__ is Allele, f'Expected parse("C*07:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_182():
    result = parse("C*07:182")
    assert result.__class__ is Allele, f'Expected parse("C*07:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_183():
    result = parse("C*07:183")
    assert result.__class__ is Allele, f'Expected parse("C*07:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_184():
    result = parse("C*07:184")
    assert result.__class__ is Allele, f'Expected parse("C*07:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_185():
    result = parse("C*07:185")
    assert result.__class__ is Allele, f'Expected parse("C*07:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_186():
    result = parse("C*07:186")
    assert result.__class__ is Allele, f'Expected parse("C*07:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_187():
    result = parse("C*07:187")
    assert result.__class__ is Allele, f'Expected parse("C*07:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_188():
    result = parse("C*07:188")
    assert result.__class__ is Allele, f'Expected parse("C*07:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_189():
    result = parse("C*07:189")
    assert result.__class__ is Allele, f'Expected parse("C*07:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_18_01_01():
    result = parse("C*07:18:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:18:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:18:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_18_01_02():
    result = parse("C*07:18:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:18:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:18:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_18_01_03():
    result = parse("C*07:18:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:18:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:18:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_18_02():
    result = parse("C*07:18:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:18:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:18:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_18_03():
    result = parse("C*07:18:03")
    assert result.__class__ is Allele, f'Expected parse("C*07:18:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:18:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_18_04():
    result = parse("C*07:18:04")
    assert result.__class__ is Allele, f'Expected parse("C*07:18:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:18:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_18_05():
    result = parse("C*07:18:05")
    assert result.__class__ is Allele, f'Expected parse("C*07:18:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:18:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_19():
    result = parse("C*07:19")
    assert result.__class__ is Allele, f'Expected parse("C*07:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_190():
    result = parse("C*07:190")
    assert result.__class__ is Allele, f'Expected parse("C*07:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_191N():
    result = parse("C*07:191N")
    assert result.__class__ is Allele, f'Expected parse("C*07:191N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:191N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_192():
    result = parse("C*07:192")
    assert result.__class__ is Allele, f'Expected parse("C*07:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_193():
    result = parse("C*07:193")
    assert result.__class__ is Allele, f'Expected parse("C*07:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_194():
    result = parse("C*07:194")
    assert result.__class__ is Allele, f'Expected parse("C*07:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_195():
    result = parse("C*07:195")
    assert result.__class__ is Allele, f'Expected parse("C*07:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_196():
    result = parse("C*07:196")
    assert result.__class__ is Allele, f'Expected parse("C*07:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_197():
    result = parse("C*07:197")
    assert result.__class__ is Allele, f'Expected parse("C*07:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_198N():
    result = parse("C*07:198N")
    assert result.__class__ is Allele, f'Expected parse("C*07:198N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:198N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_199_01():
    result = parse("C*07:199:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:199:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:199:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_199_02():
    result = parse("C*07:199:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:199:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:199:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_200():
    result = parse("C*07:200")
    assert result.__class__ is Allele, f'Expected parse("C*07:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_201():
    result = parse("C*07:201")
    assert result.__class__ is Allele, f'Expected parse("C*07:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_202():
    result = parse("C*07:202")
    assert result.__class__ is Allele, f'Expected parse("C*07:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_203():
    result = parse("C*07:203")
    assert result.__class__ is Allele, f'Expected parse("C*07:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_204_01():
    result = parse("C*07:204:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:204:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:204:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_204_02():
    result = parse("C*07:204:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:204:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:204:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_205():
    result = parse("C*07:205")
    assert result.__class__ is Allele, f'Expected parse("C*07:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_206():
    result = parse("C*07:206")
    assert result.__class__ is Allele, f'Expected parse("C*07:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_207():
    result = parse("C*07:207")
    assert result.__class__ is Allele, f'Expected parse("C*07:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_208():
    result = parse("C*07:208")
    assert result.__class__ is Allele, f'Expected parse("C*07:208") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_209():
    result = parse("C*07:209")
    assert result.__class__ is Allele, f'Expected parse("C*07:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_20_01():
    result = parse("C*07:20:01")
    assert result.__class__ is Allele, f'Expected parse("C*07:20:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:20:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_20_02():
    result = parse("C*07:20:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:20:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:20:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_21():
    result = parse("C*07:21")
    assert result.__class__ is Allele, f'Expected parse("C*07:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_210():
    result = parse("C*07:210")
    assert result.__class__ is Allele, f'Expected parse("C*07:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_211():
    result = parse("C*07:211")
    assert result.__class__ is Allele, f'Expected parse("C*07:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_212():
    result = parse("C*07:212")
    assert result.__class__ is Allele, f'Expected parse("C*07:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_213():
    result = parse("C*07:213")
    assert result.__class__ is Allele, f'Expected parse("C*07:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_214():
    result = parse("C*07:214")
    assert result.__class__ is Allele, f'Expected parse("C*07:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_215():
    result = parse("C*07:215")
    assert result.__class__ is Allele, f'Expected parse("C*07:215") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_216():
    result = parse("C*07:216")
    assert result.__class__ is Allele, f'Expected parse("C*07:216") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_217():
    result = parse("C*07:217")
    assert result.__class__ is Allele, f'Expected parse("C*07:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_218():
    result = parse("C*07:218")
    assert result.__class__ is Allele, f'Expected parse("C*07:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_219():
    result = parse("C*07:219")
    assert result.__class__ is Allele, f'Expected parse("C*07:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_22():
    result = parse("C*07:22")
    assert result.__class__ is Allele, f'Expected parse("C*07:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_220():
    result = parse("C*07:220")
    assert result.__class__ is Allele, f'Expected parse("C*07:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_221():
    result = parse("C*07:221")
    assert result.__class__ is Allele, f'Expected parse("C*07:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_222():
    result = parse("C*07:222")
    assert result.__class__ is Allele, f'Expected parse("C*07:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_223():
    result = parse("C*07:223")
    assert result.__class__ is Allele, f'Expected parse("C*07:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_224():
    result = parse("C*07:224")
    assert result.__class__ is Allele, f'Expected parse("C*07:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_225():
    result = parse("C*07:225")
    assert result.__class__ is Allele, f'Expected parse("C*07:225") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_226Q():
    result = parse("C*07:226Q")
    assert result.__class__ is Allele, f'Expected parse("C*07:226Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:226Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_227N():
    result = parse("C*07:227N")
    assert result.__class__ is Allele, f'Expected parse("C*07:227N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:227N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_228():
    result = parse("C*07:228")
    assert result.__class__ is Allele, f'Expected parse("C*07:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_229():
    result = parse("C*07:229")
    assert result.__class__ is Allele, f'Expected parse("C*07:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_23():
    result = parse("C*07:23")
    assert result.__class__ is Allele, f'Expected parse("C*07:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_230():
    result = parse("C*07:230")
    assert result.__class__ is Allele, f'Expected parse("C*07:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_231():
    result = parse("C*07:231")
    assert result.__class__ is Allele, f'Expected parse("C*07:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_232():
    result = parse("C*07:232")
    assert result.__class__ is Allele, f'Expected parse("C*07:232") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_233():
    result = parse("C*07:233")
    assert result.__class__ is Allele, f'Expected parse("C*07:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_234():
    result = parse("C*07:234")
    assert result.__class__ is Allele, f'Expected parse("C*07:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_235Q():
    result = parse("C*07:235Q")
    assert result.__class__ is Allele, f'Expected parse("C*07:235Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:235Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_236():
    result = parse("C*07:236")
    assert result.__class__ is Allele, f'Expected parse("C*07:236") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_237():
    result = parse("C*07:237")
    assert result.__class__ is Allele, f'Expected parse("C*07:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_238():
    result = parse("C*07:238")
    assert result.__class__ is Allele, f'Expected parse("C*07:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_239():
    result = parse("C*07:239")
    assert result.__class__ is Allele, f'Expected parse("C*07:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_24():
    result = parse("C*07:24")
    assert result.__class__ is Allele, f'Expected parse("C*07:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_240():
    result = parse("C*07:240")
    assert result.__class__ is Allele, f'Expected parse("C*07:240") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_241():
    result = parse("C*07:241")
    assert result.__class__ is Allele, f'Expected parse("C*07:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_242():
    result = parse("C*07:242")
    assert result.__class__ is Allele, f'Expected parse("C*07:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_243():
    result = parse("C*07:243")
    assert result.__class__ is Allele, f'Expected parse("C*07:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_244():
    result = parse("C*07:244")
    assert result.__class__ is Allele, f'Expected parse("C*07:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_245():
    result = parse("C*07:245")
    assert result.__class__ is Allele, f'Expected parse("C*07:245") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_246_01():
    result = parse("C*07:246:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:246:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:246:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_246_02():
    result = parse("C*07:246:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:246:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:246:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_247():
    result = parse("C*07:247")
    assert result.__class__ is Allele, f'Expected parse("C*07:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_248():
    result = parse("C*07:248")
    assert result.__class__ is Allele, f'Expected parse("C*07:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_249():
    result = parse("C*07:249")
    assert result.__class__ is Allele, f'Expected parse("C*07:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_25():
    result = parse("C*07:25")
    assert result.__class__ is Allele, f'Expected parse("C*07:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_250():
    result = parse("C*07:250")
    assert result.__class__ is Allele, f'Expected parse("C*07:250") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_251():
    result = parse("C*07:251")
    assert result.__class__ is Allele, f'Expected parse("C*07:251") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_252():
    result = parse("C*07:252")
    assert result.__class__ is Allele, f'Expected parse("C*07:252") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_253():
    result = parse("C*07:253")
    assert result.__class__ is Allele, f'Expected parse("C*07:253") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_254():
    result = parse("C*07:254")
    assert result.__class__ is Allele, f'Expected parse("C*07:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_255():
    result = parse("C*07:255")
    assert result.__class__ is Allele, f'Expected parse("C*07:255") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_256():
    result = parse("C*07:256")
    assert result.__class__ is Allele, f'Expected parse("C*07:256") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_257_01():
    result = parse("C*07:257:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:257:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:257:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_257_02():
    result = parse("C*07:257:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:257:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:257:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_257_03():
    result = parse("C*07:257:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:257:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:257:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_257_04():
    result = parse("C*07:257:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:257:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:257:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_258():
    result = parse("C*07:258")
    assert result.__class__ is Allele, f'Expected parse("C*07:258") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_259():
    result = parse("C*07:259")
    assert result.__class__ is Allele, f'Expected parse("C*07:259") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_260_01():
    result = parse("C*07:260:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:260:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:260:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_260_02():
    result = parse("C*07:260:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:260:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:260:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_261():
    result = parse("C*07:261")
    assert result.__class__ is Allele, f'Expected parse("C*07:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_262():
    result = parse("C*07:262")
    assert result.__class__ is Allele, f'Expected parse("C*07:262") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_263():
    result = parse("C*07:263")
    assert result.__class__ is Allele, f'Expected parse("C*07:263") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_264N():
    result = parse("C*07:264N")
    assert result.__class__ is Allele, f'Expected parse("C*07:264N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:264N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_265():
    result = parse("C*07:265")
    assert result.__class__ is Allele, f'Expected parse("C*07:265") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_266():
    result = parse("C*07:266")
    assert result.__class__ is Allele, f'Expected parse("C*07:266") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_267():
    result = parse("C*07:267")
    assert result.__class__ is Allele, f'Expected parse("C*07:267") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_268():
    result = parse("C*07:268")
    assert result.__class__ is Allele, f'Expected parse("C*07:268") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_269():
    result = parse("C*07:269")
    assert result.__class__ is Allele, f'Expected parse("C*07:269") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_26_01_01():
    result = parse("C*07:26:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:26:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:26:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_26_01_02():
    result = parse("C*07:26:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:26:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:26:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_26_02():
    result = parse("C*07:26:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:26:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:26:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_26_03():
    result = parse("C*07:26:03")
    assert result.__class__ is Allele, f'Expected parse("C*07:26:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:26:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_270():
    result = parse("C*07:270")
    assert result.__class__ is Allele, f'Expected parse("C*07:270") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_271():
    result = parse("C*07:271")
    assert result.__class__ is Allele, f'Expected parse("C*07:271") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_272():
    result = parse("C*07:272")
    assert result.__class__ is Allele, f'Expected parse("C*07:272") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_273():
    result = parse("C*07:273")
    assert result.__class__ is Allele, f'Expected parse("C*07:273") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_274():
    result = parse("C*07:274")
    assert result.__class__ is Allele, f'Expected parse("C*07:274") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_275():
    result = parse("C*07:275")
    assert result.__class__ is Allele, f'Expected parse("C*07:275") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_276():
    result = parse("C*07:276")
    assert result.__class__ is Allele, f'Expected parse("C*07:276") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_277():
    result = parse("C*07:277")
    assert result.__class__ is Allele, f'Expected parse("C*07:277") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_278():
    result = parse("C*07:278")
    assert result.__class__ is Allele, f'Expected parse("C*07:278") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_279():
    result = parse("C*07:279")
    assert result.__class__ is Allele, f'Expected parse("C*07:279") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_27_01():
    result = parse("C*07:27:01")
    assert result.__class__ is Allele, f'Expected parse("C*07:27:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:27:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_27_02():
    result = parse("C*07:27:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:27:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:27:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_28():
    result = parse("C*07:28")
    assert result.__class__ is Allele, f'Expected parse("C*07:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_280():
    result = parse("C*07:280")
    assert result.__class__ is Allele, f'Expected parse("C*07:280") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_281():
    result = parse("C*07:281")
    assert result.__class__ is Allele, f'Expected parse("C*07:281") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_282():
    result = parse("C*07:282")
    assert result.__class__ is Allele, f'Expected parse("C*07:282") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_283():
    result = parse("C*07:283")
    assert result.__class__ is Allele, f'Expected parse("C*07:283") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_284():
    result = parse("C*07:284")
    assert result.__class__ is Allele, f'Expected parse("C*07:284") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_285():
    result = parse("C*07:285")
    assert result.__class__ is Allele, f'Expected parse("C*07:285") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_286():
    result = parse("C*07:286")
    assert result.__class__ is Allele, f'Expected parse("C*07:286") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_287():
    result = parse("C*07:287")
    assert result.__class__ is Allele, f'Expected parse("C*07:287") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:287") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_288():
    result = parse("C*07:288")
    assert result.__class__ is Allele, f'Expected parse("C*07:288") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_289():
    result = parse("C*07:289")
    assert result.__class__ is Allele, f'Expected parse("C*07:289") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_290():
    result = parse("C*07:290")
    assert result.__class__ is Allele, f'Expected parse("C*07:290") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_291():
    result = parse("C*07:291")
    assert result.__class__ is Allele, f'Expected parse("C*07:291") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_292():
    result = parse("C*07:292")
    assert result.__class__ is Allele, f'Expected parse("C*07:292") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_293():
    result = parse("C*07:293")
    assert result.__class__ is Allele, f'Expected parse("C*07:293") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_294():
    result = parse("C*07:294")
    assert result.__class__ is Allele, f'Expected parse("C*07:294") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_296():
    result = parse("C*07:296")
    assert result.__class__ is Allele, f'Expected parse("C*07:296") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_297():
    result = parse("C*07:297")
    assert result.__class__ is Allele, f'Expected parse("C*07:297") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_298():
    result = parse("C*07:298")
    assert result.__class__ is Allele, f'Expected parse("C*07:298") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_299():
    result = parse("C*07:299")
    assert result.__class__ is Allele, f'Expected parse("C*07:299") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_29_01_01():
    result = parse("C*07:29:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:29:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:29:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_29_01_02():
    result = parse("C*07:29:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:29:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:29:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_29_02():
    result = parse("C*07:29:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:29:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:29:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_30():
    result = parse("C*07:30")
    assert result.__class__ is Allele, f'Expected parse("C*07:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_300():
    result = parse("C*07:300")
    assert result.__class__ is Allele, f'Expected parse("C*07:300") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_301():
    result = parse("C*07:301")
    assert result.__class__ is Allele, f'Expected parse("C*07:301") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_302():
    result = parse("C*07:302")
    assert result.__class__ is Allele, f'Expected parse("C*07:302") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_303():
    result = parse("C*07:303")
    assert result.__class__ is Allele, f'Expected parse("C*07:303") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:303") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_304():
    result = parse("C*07:304")
    assert result.__class__ is Allele, f'Expected parse("C*07:304") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:304") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_305():
    result = parse("C*07:305")
    assert result.__class__ is Allele, f'Expected parse("C*07:305") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_306():
    result = parse("C*07:306")
    assert result.__class__ is Allele, f'Expected parse("C*07:306") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:306") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_307():
    result = parse("C*07:307")
    assert result.__class__ is Allele, f'Expected parse("C*07:307") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_308():
    result = parse("C*07:308")
    assert result.__class__ is Allele, f'Expected parse("C*07:308") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:308") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_309():
    result = parse("C*07:309")
    assert result.__class__ is Allele, f'Expected parse("C*07:309") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:309") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_310():
    result = parse("C*07:310")
    assert result.__class__ is Allele, f'Expected parse("C*07:310") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:310") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_311():
    result = parse("C*07:311")
    assert result.__class__ is Allele, f'Expected parse("C*07:311") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:311") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_312():
    result = parse("C*07:312")
    assert result.__class__ is Allele, f'Expected parse("C*07:312") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:312") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_313():
    result = parse("C*07:313")
    assert result.__class__ is Allele, f'Expected parse("C*07:313") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:313") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_314_01():
    result = parse("C*07:314:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:314:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:314:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_314_02():
    result = parse("C*07:314:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:314:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:314:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_314_03():
    result = parse("C*07:314:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:314:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:314:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_315():
    result = parse("C*07:315")
    assert result.__class__ is Allele, f'Expected parse("C*07:315") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:315") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_316():
    result = parse("C*07:316")
    assert result.__class__ is Allele, f'Expected parse("C*07:316") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:316") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_317():
    result = parse("C*07:317")
    assert result.__class__ is Allele, f'Expected parse("C*07:317") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:317") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_318():
    result = parse("C*07:318")
    assert result.__class__ is Allele, f'Expected parse("C*07:318") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:318") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_319():
    result = parse("C*07:319")
    assert result.__class__ is Allele, f'Expected parse("C*07:319") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_31_01():
    result = parse("C*07:31:01")
    assert result.__class__ is Allele, f'Expected parse("C*07:31:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:31:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_31_02():
    result = parse("C*07:31:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:31:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:31:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_320():
    result = parse("C*07:320")
    assert result.__class__ is Allele, f'Expected parse("C*07:320") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:320") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_321():
    result = parse("C*07:321")
    assert result.__class__ is Allele, f'Expected parse("C*07:321") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:321") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_322():
    result = parse("C*07:322")
    assert result.__class__ is Allele, f'Expected parse("C*07:322") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:322") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_323():
    result = parse("C*07:323")
    assert result.__class__ is Allele, f'Expected parse("C*07:323") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:323") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_324():
    result = parse("C*07:324")
    assert result.__class__ is Allele, f'Expected parse("C*07:324") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:324") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_325():
    result = parse("C*07:325")
    assert result.__class__ is Allele, f'Expected parse("C*07:325") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:325") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_326():
    result = parse("C*07:326")
    assert result.__class__ is Allele, f'Expected parse("C*07:326") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:326") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_327():
    result = parse("C*07:327")
    assert result.__class__ is Allele, f'Expected parse("C*07:327") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:327") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_328():
    result = parse("C*07:328")
    assert result.__class__ is Allele, f'Expected parse("C*07:328") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:328") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_329N():
    result = parse("C*07:329N")
    assert result.__class__ is Allele, f'Expected parse("C*07:329N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:329N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_32N():
    result = parse("C*07:32N")
    assert result.__class__ is Allele, f'Expected parse("C*07:32N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:32N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_330_01():
    result = parse("C*07:330:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:330:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:330:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_330_02():
    result = parse("C*07:330:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:330:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:330:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_331():
    result = parse("C*07:331")
    assert result.__class__ is Allele, f'Expected parse("C*07:331") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:331") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_332():
    result = parse("C*07:332")
    assert result.__class__ is Allele, f'Expected parse("C*07:332") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:332") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_333():
    result = parse("C*07:333")
    assert result.__class__ is Allele, f'Expected parse("C*07:333") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:333") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_334():
    result = parse("C*07:334")
    assert result.__class__ is Allele, f'Expected parse("C*07:334") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:334") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_335():
    result = parse("C*07:335")
    assert result.__class__ is Allele, f'Expected parse("C*07:335") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:335") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_336():
    result = parse("C*07:336")
    assert result.__class__ is Allele, f'Expected parse("C*07:336") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:336") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_337():
    result = parse("C*07:337")
    assert result.__class__ is Allele, f'Expected parse("C*07:337") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:337") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_338():
    result = parse("C*07:338")
    assert result.__class__ is Allele, f'Expected parse("C*07:338") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:338") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_339():
    result = parse("C*07:339")
    assert result.__class__ is Allele, f'Expected parse("C*07:339") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:339") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_33N():
    result = parse("C*07:33N")
    assert result.__class__ is Allele, f'Expected parse("C*07:33N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:33N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_340():
    result = parse("C*07:340")
    assert result.__class__ is Allele, f'Expected parse("C*07:340") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:340") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_341_01():
    result = parse("C*07:341:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:341:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:341:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_341_02():
    result = parse("C*07:341:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:341:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:341:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_342():
    result = parse("C*07:342")
    assert result.__class__ is Allele, f'Expected parse("C*07:342") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:342") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_343_01_01():
    result = parse("C*07:343:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:343:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:343:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_343_01_02():
    result = parse("C*07:343:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:343:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:343:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_344():
    result = parse("C*07:344")
    assert result.__class__ is Allele, f'Expected parse("C*07:344") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:344") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_345():
    result = parse("C*07:345")
    assert result.__class__ is Allele, f'Expected parse("C*07:345") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:345") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_346():
    result = parse("C*07:346")
    assert result.__class__ is Allele, f'Expected parse("C*07:346") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:346") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_347N():
    result = parse("C*07:347N")
    assert result.__class__ is Allele, f'Expected parse("C*07:347N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:347N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_348():
    result = parse("C*07:348")
    assert result.__class__ is Allele, f'Expected parse("C*07:348") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:348") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_349():
    result = parse("C*07:349")
    assert result.__class__ is Allele, f'Expected parse("C*07:349") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:349") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_35():
    result = parse("C*07:35")
    assert result.__class__ is Allele, f'Expected parse("C*07:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_350N():
    result = parse("C*07:350N")
    assert result.__class__ is Allele, f'Expected parse("C*07:350N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:350N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_351():
    result = parse("C*07:351")
    assert result.__class__ is Allele, f'Expected parse("C*07:351") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:351") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_352():
    result = parse("C*07:352")
    assert result.__class__ is Allele, f'Expected parse("C*07:352") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:352") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_353():
    result = parse("C*07:353")
    assert result.__class__ is Allele, f'Expected parse("C*07:353") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:353") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_354():
    result = parse("C*07:354")
    assert result.__class__ is Allele, f'Expected parse("C*07:354") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:354") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_355():
    result = parse("C*07:355")
    assert result.__class__ is Allele, f'Expected parse("C*07:355") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:355") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_356():
    result = parse("C*07:356")
    assert result.__class__ is Allele, f'Expected parse("C*07:356") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:356") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_357():
    result = parse("C*07:357")
    assert result.__class__ is Allele, f'Expected parse("C*07:357") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:357") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_358():
    result = parse("C*07:358")
    assert result.__class__ is Allele, f'Expected parse("C*07:358") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:358") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_359():
    result = parse("C*07:359")
    assert result.__class__ is Allele, f'Expected parse("C*07:359") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:359") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_36():
    result = parse("C*07:36")
    assert result.__class__ is Allele, f'Expected parse("C*07:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_360():
    result = parse("C*07:360")
    assert result.__class__ is Allele, f'Expected parse("C*07:360") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:360") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_361():
    result = parse("C*07:361")
    assert result.__class__ is Allele, f'Expected parse("C*07:361") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:361") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_362():
    result = parse("C*07:362")
    assert result.__class__ is Allele, f'Expected parse("C*07:362") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:362") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_363():
    result = parse("C*07:363")
    assert result.__class__ is Allele, f'Expected parse("C*07:363") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:363") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_364():
    result = parse("C*07:364")
    assert result.__class__ is Allele, f'Expected parse("C*07:364") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:364") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_365():
    result = parse("C*07:365")
    assert result.__class__ is Allele, f'Expected parse("C*07:365") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:365") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_366():
    result = parse("C*07:366")
    assert result.__class__ is Allele, f'Expected parse("C*07:366") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:366") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_367():
    result = parse("C*07:367")
    assert result.__class__ is Allele, f'Expected parse("C*07:367") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:367") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_368_01():
    result = parse("C*07:368:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:368:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:368:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_368_02():
    result = parse("C*07:368:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:368:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:368:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_369():
    result = parse("C*07:369")
    assert result.__class__ is Allele, f'Expected parse("C*07:369") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:369") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_37():
    result = parse("C*07:37")
    assert result.__class__ is Allele, f'Expected parse("C*07:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_370():
    result = parse("C*07:370")
    assert result.__class__ is Allele, f'Expected parse("C*07:370") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:370") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_371():
    result = parse("C*07:371")
    assert result.__class__ is Allele, f'Expected parse("C*07:371") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:371") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_372():
    result = parse("C*07:372")
    assert result.__class__ is Allele, f'Expected parse("C*07:372") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:372") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_373():
    result = parse("C*07:373")
    assert result.__class__ is Allele, f'Expected parse("C*07:373") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:373") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_374():
    result = parse("C*07:374")
    assert result.__class__ is Allele, f'Expected parse("C*07:374") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:374") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_375():
    result = parse("C*07:375")
    assert result.__class__ is Allele, f'Expected parse("C*07:375") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:375") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_376():
    result = parse("C*07:376")
    assert result.__class__ is Allele, f'Expected parse("C*07:376") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:376") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_377():
    result = parse("C*07:377")
    assert result.__class__ is Allele, f'Expected parse("C*07:377") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:377") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_378():
    result = parse("C*07:378")
    assert result.__class__ is Allele, f'Expected parse("C*07:378") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:378") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_379():
    result = parse("C*07:379")
    assert result.__class__ is Allele, f'Expected parse("C*07:379") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:379") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_380():
    result = parse("C*07:380")
    assert result.__class__ is Allele, f'Expected parse("C*07:380") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:380") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_381():
    result = parse("C*07:381")
    assert result.__class__ is Allele, f'Expected parse("C*07:381") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:381") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_382():
    result = parse("C*07:382")
    assert result.__class__ is Allele, f'Expected parse("C*07:382") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:382") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_383():
    result = parse("C*07:383")
    assert result.__class__ is Allele, f'Expected parse("C*07:383") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:383") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_384():
    result = parse("C*07:384")
    assert result.__class__ is Allele, f'Expected parse("C*07:384") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:384") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_385():
    result = parse("C*07:385")
    assert result.__class__ is Allele, f'Expected parse("C*07:385") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:385") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_386():
    result = parse("C*07:386")
    assert result.__class__ is Allele, f'Expected parse("C*07:386") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:386") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_387():
    result = parse("C*07:387")
    assert result.__class__ is Allele, f'Expected parse("C*07:387") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:387") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_388():
    result = parse("C*07:388")
    assert result.__class__ is Allele, f'Expected parse("C*07:388") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:388") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_389():
    result = parse("C*07:389")
    assert result.__class__ is Allele, f'Expected parse("C*07:389") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:389") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_38_01():
    result = parse("C*07:38:01")
    assert result.__class__ is Allele, f'Expected parse("C*07:38:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:38:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_38_02():
    result = parse("C*07:38:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:38:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:38:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_39():
    result = parse("C*07:39")
    assert result.__class__ is Allele, f'Expected parse("C*07:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_390():
    result = parse("C*07:390")
    assert result.__class__ is Allele, f'Expected parse("C*07:390") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:390") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_391():
    result = parse("C*07:391")
    assert result.__class__ is Allele, f'Expected parse("C*07:391") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:391") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_392():
    result = parse("C*07:392")
    assert result.__class__ is Allele, f'Expected parse("C*07:392") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:392") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_393N():
    result = parse("C*07:393N")
    assert result.__class__ is Allele, f'Expected parse("C*07:393N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:393N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_394():
    result = parse("C*07:394")
    assert result.__class__ is Allele, f'Expected parse("C*07:394") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:394") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_395():
    result = parse("C*07:395")
    assert result.__class__ is Allele, f'Expected parse("C*07:395") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:395") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_396():
    result = parse("C*07:396")
    assert result.__class__ is Allele, f'Expected parse("C*07:396") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:396") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_397():
    result = parse("C*07:397")
    assert result.__class__ is Allele, f'Expected parse("C*07:397") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:397") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_398():
    result = parse("C*07:398")
    assert result.__class__ is Allele, f'Expected parse("C*07:398") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:398") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_399():
    result = parse("C*07:399")
    assert result.__class__ is Allele, f'Expected parse("C*07:399") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:399") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_40():
    result = parse("C*07:40")
    assert result.__class__ is Allele, f'Expected parse("C*07:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_400():
    result = parse("C*07:400")
    assert result.__class__ is Allele, f'Expected parse("C*07:400") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:400") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_401():
    result = parse("C*07:401")
    assert result.__class__ is Allele, f'Expected parse("C*07:401") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:401") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_402():
    result = parse("C*07:402")
    assert result.__class__ is Allele, f'Expected parse("C*07:402") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:402") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_403():
    result = parse("C*07:403")
    assert result.__class__ is Allele, f'Expected parse("C*07:403") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:403") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_404():
    result = parse("C*07:404")
    assert result.__class__ is Allele, f'Expected parse("C*07:404") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:404") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_405():
    result = parse("C*07:405")
    assert result.__class__ is Allele, f'Expected parse("C*07:405") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:405") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_406():
    result = parse("C*07:406")
    assert result.__class__ is Allele, f'Expected parse("C*07:406") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:406") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_407():
    result = parse("C*07:407")
    assert result.__class__ is Allele, f'Expected parse("C*07:407") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:407") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_408():
    result = parse("C*07:408")
    assert result.__class__ is Allele, f'Expected parse("C*07:408") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:408") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_409():
    result = parse("C*07:409")
    assert result.__class__ is Allele, f'Expected parse("C*07:409") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:409") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_41():
    result = parse("C*07:41")
    assert result.__class__ is Allele, f'Expected parse("C*07:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_410():
    result = parse("C*07:410")
    assert result.__class__ is Allele, f'Expected parse("C*07:410") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:410") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_411():
    result = parse("C*07:411")
    assert result.__class__ is Allele, f'Expected parse("C*07:411") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:411") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_412():
    result = parse("C*07:412")
    assert result.__class__ is Allele, f'Expected parse("C*07:412") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:412") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_413():
    result = parse("C*07:413")
    assert result.__class__ is Allele, f'Expected parse("C*07:413") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:413") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_414():
    result = parse("C*07:414")
    assert result.__class__ is Allele, f'Expected parse("C*07:414") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:414") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_415():
    result = parse("C*07:415")
    assert result.__class__ is Allele, f'Expected parse("C*07:415") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:415") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_416():
    result = parse("C*07:416")
    assert result.__class__ is Allele, f'Expected parse("C*07:416") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:416") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_417():
    result = parse("C*07:417")
    assert result.__class__ is Allele, f'Expected parse("C*07:417") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:417") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_418():
    result = parse("C*07:418")
    assert result.__class__ is Allele, f'Expected parse("C*07:418") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:418") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_419():
    result = parse("C*07:419")
    assert result.__class__ is Allele, f'Expected parse("C*07:419") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:419") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_42():
    result = parse("C*07:42")
    assert result.__class__ is Allele, f'Expected parse("C*07:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_420():
    result = parse("C*07:420")
    assert result.__class__ is Allele, f'Expected parse("C*07:420") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:420") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_421():
    result = parse("C*07:421")
    assert result.__class__ is Allele, f'Expected parse("C*07:421") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:421") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_422():
    result = parse("C*07:422")
    assert result.__class__ is Allele, f'Expected parse("C*07:422") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:422") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_423():
    result = parse("C*07:423")
    assert result.__class__ is Allele, f'Expected parse("C*07:423") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:423") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_424():
    result = parse("C*07:424")
    assert result.__class__ is Allele, f'Expected parse("C*07:424") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:424") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_425():
    result = parse("C*07:425")
    assert result.__class__ is Allele, f'Expected parse("C*07:425") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:425") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_426():
    result = parse("C*07:426")
    assert result.__class__ is Allele, f'Expected parse("C*07:426") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:426") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_427():
    result = parse("C*07:427")
    assert result.__class__ is Allele, f'Expected parse("C*07:427") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:427") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_428():
    result = parse("C*07:428")
    assert result.__class__ is Allele, f'Expected parse("C*07:428") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:428") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_429():
    result = parse("C*07:429")
    assert result.__class__ is Allele, f'Expected parse("C*07:429") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:429") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_430():
    result = parse("C*07:430")
    assert result.__class__ is Allele, f'Expected parse("C*07:430") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:430") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_431():
    result = parse("C*07:431")
    assert result.__class__ is Allele, f'Expected parse("C*07:431") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:431") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_432Q():
    result = parse("C*07:432Q")
    assert result.__class__ is Allele, f'Expected parse("C*07:432Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:432Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_433():
    result = parse("C*07:433")
    assert result.__class__ is Allele, f'Expected parse("C*07:433") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:433") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_434():
    result = parse("C*07:434")
    assert result.__class__ is Allele, f'Expected parse("C*07:434") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:434") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_435():
    result = parse("C*07:435")
    assert result.__class__ is Allele, f'Expected parse("C*07:435") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:435") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_436():
    result = parse("C*07:436")
    assert result.__class__ is Allele, f'Expected parse("C*07:436") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:436") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_437N():
    result = parse("C*07:437N")
    assert result.__class__ is Allele, f'Expected parse("C*07:437N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:437N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_438():
    result = parse("C*07:438")
    assert result.__class__ is Allele, f'Expected parse("C*07:438") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:438") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_439():
    result = parse("C*07:439")
    assert result.__class__ is Allele, f'Expected parse("C*07:439") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:439") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_43_01():
    result = parse("C*07:43:01")
    assert result.__class__ is Allele, f'Expected parse("C*07:43:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:43:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_43_02():
    result = parse("C*07:43:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:43:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:43:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_44():
    result = parse("C*07:44")
    assert result.__class__ is Allele, f'Expected parse("C*07:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_440():
    result = parse("C*07:440")
    assert result.__class__ is Allele, f'Expected parse("C*07:440") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:440") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_441_01():
    result = parse("C*07:441:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:441:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:441:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_441_02():
    result = parse("C*07:441:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:441:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:441:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_442():
    result = parse("C*07:442")
    assert result.__class__ is Allele, f'Expected parse("C*07:442") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:442") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_443():
    result = parse("C*07:443")
    assert result.__class__ is Allele, f'Expected parse("C*07:443") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:443") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_444():
    result = parse("C*07:444")
    assert result.__class__ is Allele, f'Expected parse("C*07:444") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:444") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_445():
    result = parse("C*07:445")
    assert result.__class__ is Allele, f'Expected parse("C*07:445") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:445") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_446():
    result = parse("C*07:446")
    assert result.__class__ is Allele, f'Expected parse("C*07:446") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:446") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_447():
    result = parse("C*07:447")
    assert result.__class__ is Allele, f'Expected parse("C*07:447") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:447") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_448():
    result = parse("C*07:448")
    assert result.__class__ is Allele, f'Expected parse("C*07:448") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:448") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_449():
    result = parse("C*07:449")
    assert result.__class__ is Allele, f'Expected parse("C*07:449") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:449") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_45():
    result = parse("C*07:45")
    assert result.__class__ is Allele, f'Expected parse("C*07:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_450():
    result = parse("C*07:450")
    assert result.__class__ is Allele, f'Expected parse("C*07:450") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:450") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_451N():
    result = parse("C*07:451N")
    assert result.__class__ is Allele, f'Expected parse("C*07:451N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:451N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_452N():
    result = parse("C*07:452N")
    assert result.__class__ is Allele, f'Expected parse("C*07:452N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:452N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_453():
    result = parse("C*07:453")
    assert result.__class__ is Allele, f'Expected parse("C*07:453") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:453") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_454_01():
    result = parse("C*07:454:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:454:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:454:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_454_02():
    result = parse("C*07:454:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:454:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:454:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_455():
    result = parse("C*07:455")
    assert result.__class__ is Allele, f'Expected parse("C*07:455") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:455") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_456():
    result = parse("C*07:456")
    assert result.__class__ is Allele, f'Expected parse("C*07:456") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:456") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_457():
    result = parse("C*07:457")
    assert result.__class__ is Allele, f'Expected parse("C*07:457") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:457") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_458():
    result = parse("C*07:458")
    assert result.__class__ is Allele, f'Expected parse("C*07:458") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:458") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_459():
    result = parse("C*07:459")
    assert result.__class__ is Allele, f'Expected parse("C*07:459") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:459") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_46():
    result = parse("C*07:46")
    assert result.__class__ is Allele, f'Expected parse("C*07:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_460():
    result = parse("C*07:460")
    assert result.__class__ is Allele, f'Expected parse("C*07:460") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:460") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_461():
    result = parse("C*07:461")
    assert result.__class__ is Allele, f'Expected parse("C*07:461") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:461") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_462():
    result = parse("C*07:462")
    assert result.__class__ is Allele, f'Expected parse("C*07:462") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:462") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_463():
    result = parse("C*07:463")
    assert result.__class__ is Allele, f'Expected parse("C*07:463") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:463") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_464():
    result = parse("C*07:464")
    assert result.__class__ is Allele, f'Expected parse("C*07:464") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:464") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_465():
    result = parse("C*07:465")
    assert result.__class__ is Allele, f'Expected parse("C*07:465") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:465") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_466():
    result = parse("C*07:466")
    assert result.__class__ is Allele, f'Expected parse("C*07:466") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:466") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_467():
    result = parse("C*07:467")
    assert result.__class__ is Allele, f'Expected parse("C*07:467") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:467") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_468():
    result = parse("C*07:468")
    assert result.__class__ is Allele, f'Expected parse("C*07:468") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:468") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_469():
    result = parse("C*07:469")
    assert result.__class__ is Allele, f'Expected parse("C*07:469") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:469") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_47():
    result = parse("C*07:47")
    assert result.__class__ is Allele, f'Expected parse("C*07:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_470():
    result = parse("C*07:470")
    assert result.__class__ is Allele, f'Expected parse("C*07:470") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:470") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_471():
    result = parse("C*07:471")
    assert result.__class__ is Allele, f'Expected parse("C*07:471") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:471") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_472():
    result = parse("C*07:472")
    assert result.__class__ is Allele, f'Expected parse("C*07:472") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:472") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_473():
    result = parse("C*07:473")
    assert result.__class__ is Allele, f'Expected parse("C*07:473") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:473") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_474():
    result = parse("C*07:474")
    assert result.__class__ is Allele, f'Expected parse("C*07:474") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:474") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_475():
    result = parse("C*07:475")
    assert result.__class__ is Allele, f'Expected parse("C*07:475") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:475") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_476N():
    result = parse("C*07:476N")
    assert result.__class__ is Allele, f'Expected parse("C*07:476N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:476N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_477():
    result = parse("C*07:477")
    assert result.__class__ is Allele, f'Expected parse("C*07:477") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:477") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_478():
    result = parse("C*07:478")
    assert result.__class__ is Allele, f'Expected parse("C*07:478") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:478") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_479():
    result = parse("C*07:479")
    assert result.__class__ is Allele, f'Expected parse("C*07:479") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:479") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_48():
    result = parse("C*07:48")
    assert result.__class__ is Allele, f'Expected parse("C*07:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_480():
    result = parse("C*07:480")
    assert result.__class__ is Allele, f'Expected parse("C*07:480") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:480") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_481():
    result = parse("C*07:481")
    assert result.__class__ is Allele, f'Expected parse("C*07:481") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:481") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_482():
    result = parse("C*07:482")
    assert result.__class__ is Allele, f'Expected parse("C*07:482") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:482") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_483N():
    result = parse("C*07:483N")
    assert result.__class__ is Allele, f'Expected parse("C*07:483N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:483N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_484N():
    result = parse("C*07:484N")
    assert result.__class__ is Allele, f'Expected parse("C*07:484N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:484N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_485():
    result = parse("C*07:485")
    assert result.__class__ is Allele, f'Expected parse("C*07:485") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:485") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_486():
    result = parse("C*07:486")
    assert result.__class__ is Allele, f'Expected parse("C*07:486") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:486") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_487():
    result = parse("C*07:487")
    assert result.__class__ is Allele, f'Expected parse("C*07:487") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:487") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_488():
    result = parse("C*07:488")
    assert result.__class__ is Allele, f'Expected parse("C*07:488") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:488") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_489_01():
    result = parse("C*07:489:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:489:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:489:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_489_02():
    result = parse("C*07:489:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:489:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:489:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_49():
    result = parse("C*07:49")
    assert result.__class__ is Allele, f'Expected parse("C*07:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_490():
    result = parse("C*07:490")
    assert result.__class__ is Allele, f'Expected parse("C*07:490") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:490") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_491_01N():
    result = parse("C*07:491:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:491:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:491:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_491_02N():
    result = parse("C*07:491:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:491:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:491:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_492():
    result = parse("C*07:492")
    assert result.__class__ is Allele, f'Expected parse("C*07:492") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:492") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_493():
    result = parse("C*07:493")
    assert result.__class__ is Allele, f'Expected parse("C*07:493") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:493") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_494Q():
    result = parse("C*07:494Q")
    assert result.__class__ is Allele, f'Expected parse("C*07:494Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:494Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_495():
    result = parse("C*07:495")
    assert result.__class__ is Allele, f'Expected parse("C*07:495") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:495") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_496():
    result = parse("C*07:496")
    assert result.__class__ is Allele, f'Expected parse("C*07:496") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:496") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_497():
    result = parse("C*07:497")
    assert result.__class__ is Allele, f'Expected parse("C*07:497") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:497") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_498():
    result = parse("C*07:498")
    assert result.__class__ is Allele, f'Expected parse("C*07:498") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:498") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_499():
    result = parse("C*07:499")
    assert result.__class__ is Allele, f'Expected parse("C*07:499") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:499") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_50():
    result = parse("C*07:50")
    assert result.__class__ is Allele, f'Expected parse("C*07:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_500():
    result = parse("C*07:500")
    assert result.__class__ is Allele, f'Expected parse("C*07:500") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:500") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_501():
    result = parse("C*07:501")
    assert result.__class__ is Allele, f'Expected parse("C*07:501") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:501") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_502():
    result = parse("C*07:502")
    assert result.__class__ is Allele, f'Expected parse("C*07:502") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:502") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_503():
    result = parse("C*07:503")
    assert result.__class__ is Allele, f'Expected parse("C*07:503") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:503") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_504():
    result = parse("C*07:504")
    assert result.__class__ is Allele, f'Expected parse("C*07:504") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:504") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_505():
    result = parse("C*07:505")
    assert result.__class__ is Allele, f'Expected parse("C*07:505") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:505") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_506():
    result = parse("C*07:506")
    assert result.__class__ is Allele, f'Expected parse("C*07:506") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:506") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_507N():
    result = parse("C*07:507N")
    assert result.__class__ is Allele, f'Expected parse("C*07:507N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:507N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_508():
    result = parse("C*07:508")
    assert result.__class__ is Allele, f'Expected parse("C*07:508") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:508") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_509():
    result = parse("C*07:509")
    assert result.__class__ is Allele, f'Expected parse("C*07:509") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:509") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_51():
    result = parse("C*07:51")
    assert result.__class__ is Allele, f'Expected parse("C*07:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_510():
    result = parse("C*07:510")
    assert result.__class__ is Allele, f'Expected parse("C*07:510") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:510") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_511():
    result = parse("C*07:511")
    assert result.__class__ is Allele, f'Expected parse("C*07:511") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:511") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_512():
    result = parse("C*07:512")
    assert result.__class__ is Allele, f'Expected parse("C*07:512") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:512") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_513Q():
    result = parse("C*07:513Q")
    assert result.__class__ is Allele, f'Expected parse("C*07:513Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:513Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_514():
    result = parse("C*07:514")
    assert result.__class__ is Allele, f'Expected parse("C*07:514") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:514") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_515():
    result = parse("C*07:515")
    assert result.__class__ is Allele, f'Expected parse("C*07:515") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:515") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_516():
    result = parse("C*07:516")
    assert result.__class__ is Allele, f'Expected parse("C*07:516") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:516") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_517():
    result = parse("C*07:517")
    assert result.__class__ is Allele, f'Expected parse("C*07:517") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:517") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_518():
    result = parse("C*07:518")
    assert result.__class__ is Allele, f'Expected parse("C*07:518") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:518") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_519():
    result = parse("C*07:519")
    assert result.__class__ is Allele, f'Expected parse("C*07:519") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:519") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_52():
    result = parse("C*07:52")
    assert result.__class__ is Allele, f'Expected parse("C*07:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_520():
    result = parse("C*07:520")
    assert result.__class__ is Allele, f'Expected parse("C*07:520") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:520") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_521_01():
    result = parse("C*07:521:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:521:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:521:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_521_02():
    result = parse("C*07:521:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:521:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:521:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_522():
    result = parse("C*07:522")
    assert result.__class__ is Allele, f'Expected parse("C*07:522") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:522") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_523():
    result = parse("C*07:523")
    assert result.__class__ is Allele, f'Expected parse("C*07:523") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:523") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_524():
    result = parse("C*07:524")
    assert result.__class__ is Allele, f'Expected parse("C*07:524") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:524") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_525():
    result = parse("C*07:525")
    assert result.__class__ is Allele, f'Expected parse("C*07:525") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:525") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_526_01():
    result = parse("C*07:526:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:526:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:526:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_526_02():
    result = parse("C*07:526:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:526:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:526:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_527():
    result = parse("C*07:527")
    assert result.__class__ is Allele, f'Expected parse("C*07:527") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:527") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_528():
    result = parse("C*07:528")
    assert result.__class__ is Allele, f'Expected parse("C*07:528") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:528") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_529():
    result = parse("C*07:529")
    assert result.__class__ is Allele, f'Expected parse("C*07:529") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:529") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_53():
    result = parse("C*07:53")
    assert result.__class__ is Allele, f'Expected parse("C*07:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_530():
    result = parse("C*07:530")
    assert result.__class__ is Allele, f'Expected parse("C*07:530") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:530") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_531():
    result = parse("C*07:531")
    assert result.__class__ is Allele, f'Expected parse("C*07:531") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:531") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_532():
    result = parse("C*07:532")
    assert result.__class__ is Allele, f'Expected parse("C*07:532") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:532") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_533():
    result = parse("C*07:533")
    assert result.__class__ is Allele, f'Expected parse("C*07:533") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:533") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_534():
    result = parse("C*07:534")
    assert result.__class__ is Allele, f'Expected parse("C*07:534") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:534") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_535():
    result = parse("C*07:535")
    assert result.__class__ is Allele, f'Expected parse("C*07:535") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:535") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_536():
    result = parse("C*07:536")
    assert result.__class__ is Allele, f'Expected parse("C*07:536") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:536") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_537():
    result = parse("C*07:537")
    assert result.__class__ is Allele, f'Expected parse("C*07:537") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:537") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_538():
    result = parse("C*07:538")
    assert result.__class__ is Allele, f'Expected parse("C*07:538") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:538") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_539():
    result = parse("C*07:539")
    assert result.__class__ is Allele, f'Expected parse("C*07:539") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:539") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_54():
    result = parse("C*07:54")
    assert result.__class__ is Allele, f'Expected parse("C*07:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_540():
    result = parse("C*07:540")
    assert result.__class__ is Allele, f'Expected parse("C*07:540") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:540") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_541():
    result = parse("C*07:541")
    assert result.__class__ is Allele, f'Expected parse("C*07:541") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:541") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_542():
    result = parse("C*07:542")
    assert result.__class__ is Allele, f'Expected parse("C*07:542") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:542") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_543():
    result = parse("C*07:543")
    assert result.__class__ is Allele, f'Expected parse("C*07:543") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:543") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_544():
    result = parse("C*07:544")
    assert result.__class__ is Allele, f'Expected parse("C*07:544") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:544") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_545():
    result = parse("C*07:545")
    assert result.__class__ is Allele, f'Expected parse("C*07:545") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:545") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_546():
    result = parse("C*07:546")
    assert result.__class__ is Allele, f'Expected parse("C*07:546") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:546") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_547():
    result = parse("C*07:547")
    assert result.__class__ is Allele, f'Expected parse("C*07:547") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:547") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_548():
    result = parse("C*07:548")
    assert result.__class__ is Allele, f'Expected parse("C*07:548") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:548") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_549():
    result = parse("C*07:549")
    assert result.__class__ is Allele, f'Expected parse("C*07:549") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:549") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_550():
    result = parse("C*07:550")
    assert result.__class__ is Allele, f'Expected parse("C*07:550") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:550") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_551N():
    result = parse("C*07:551N")
    assert result.__class__ is Allele, f'Expected parse("C*07:551N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:551N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_552():
    result = parse("C*07:552")
    assert result.__class__ is Allele, f'Expected parse("C*07:552") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:552") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_553():
    result = parse("C*07:553")
    assert result.__class__ is Allele, f'Expected parse("C*07:553") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:553") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_554():
    result = parse("C*07:554")
    assert result.__class__ is Allele, f'Expected parse("C*07:554") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:554") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_555():
    result = parse("C*07:555")
    assert result.__class__ is Allele, f'Expected parse("C*07:555") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:555") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_556():
    result = parse("C*07:556")
    assert result.__class__ is Allele, f'Expected parse("C*07:556") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:556") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_557():
    result = parse("C*07:557")
    assert result.__class__ is Allele, f'Expected parse("C*07:557") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:557") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_558_01_01():
    result = parse("C*07:558:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:558:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:558:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_558_01_02():
    result = parse("C*07:558:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:558:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:558:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_559():
    result = parse("C*07:559")
    assert result.__class__ is Allele, f'Expected parse("C*07:559") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:559") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_55N():
    result = parse("C*07:55N")
    assert result.__class__ is Allele, f'Expected parse("C*07:55N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:55N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_560():
    result = parse("C*07:560")
    assert result.__class__ is Allele, f'Expected parse("C*07:560") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:560") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_561():
    result = parse("C*07:561")
    assert result.__class__ is Allele, f'Expected parse("C*07:561") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:561") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_562():
    result = parse("C*07:562")
    assert result.__class__ is Allele, f'Expected parse("C*07:562") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:562") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_563():
    result = parse("C*07:563")
    assert result.__class__ is Allele, f'Expected parse("C*07:563") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:563") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_564():
    result = parse("C*07:564")
    assert result.__class__ is Allele, f'Expected parse("C*07:564") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:564") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_565():
    result = parse("C*07:565")
    assert result.__class__ is Allele, f'Expected parse("C*07:565") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:565") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_566():
    result = parse("C*07:566")
    assert result.__class__ is Allele, f'Expected parse("C*07:566") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:566") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_567():
    result = parse("C*07:567")
    assert result.__class__ is Allele, f'Expected parse("C*07:567") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:567") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_568():
    result = parse("C*07:568")
    assert result.__class__ is Allele, f'Expected parse("C*07:568") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:568") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_569():
    result = parse("C*07:569")
    assert result.__class__ is Allele, f'Expected parse("C*07:569") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:569") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_56_01():
    result = parse("C*07:56:01")
    assert result.__class__ is Allele, f'Expected parse("C*07:56:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:56:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_56_02():
    result = parse("C*07:56:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:56:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:56:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_57():
    result = parse("C*07:57")
    assert result.__class__ is Allele, f'Expected parse("C*07:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_570():
    result = parse("C*07:570")
    assert result.__class__ is Allele, f'Expected parse("C*07:570") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:570") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_571():
    result = parse("C*07:571")
    assert result.__class__ is Allele, f'Expected parse("C*07:571") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:571") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_572():
    result = parse("C*07:572")
    assert result.__class__ is Allele, f'Expected parse("C*07:572") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:572") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_573():
    result = parse("C*07:573")
    assert result.__class__ is Allele, f'Expected parse("C*07:573") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:573") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_574():
    result = parse("C*07:574")
    assert result.__class__ is Allele, f'Expected parse("C*07:574") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:574") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_575_01():
    result = parse("C*07:575:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:575:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:575:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_575_02():
    result = parse("C*07:575:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:575:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:575:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_576():
    result = parse("C*07:576")
    assert result.__class__ is Allele, f'Expected parse("C*07:576") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:576") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_577():
    result = parse("C*07:577")
    assert result.__class__ is Allele, f'Expected parse("C*07:577") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:577") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_578():
    result = parse("C*07:578")
    assert result.__class__ is Allele, f'Expected parse("C*07:578") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:578") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_579():
    result = parse("C*07:579")
    assert result.__class__ is Allele, f'Expected parse("C*07:579") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:579") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_58():
    result = parse("C*07:58")
    assert result.__class__ is Allele, f'Expected parse("C*07:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_580():
    result = parse("C*07:580")
    assert result.__class__ is Allele, f'Expected parse("C*07:580") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:580") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_581():
    result = parse("C*07:581")
    assert result.__class__ is Allele, f'Expected parse("C*07:581") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:581") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_582Q():
    result = parse("C*07:582Q")
    assert result.__class__ is Allele, f'Expected parse("C*07:582Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:582Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_583():
    result = parse("C*07:583")
    assert result.__class__ is Allele, f'Expected parse("C*07:583") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:583") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_584():
    result = parse("C*07:584")
    assert result.__class__ is Allele, f'Expected parse("C*07:584") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:584") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_585():
    result = parse("C*07:585")
    assert result.__class__ is Allele, f'Expected parse("C*07:585") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:585") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_586():
    result = parse("C*07:586")
    assert result.__class__ is Allele, f'Expected parse("C*07:586") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:586") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_587():
    result = parse("C*07:587")
    assert result.__class__ is Allele, f'Expected parse("C*07:587") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:587") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_588():
    result = parse("C*07:588")
    assert result.__class__ is Allele, f'Expected parse("C*07:588") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:588") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_589():
    result = parse("C*07:589")
    assert result.__class__ is Allele, f'Expected parse("C*07:589") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:589") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_59():
    result = parse("C*07:59")
    assert result.__class__ is Allele, f'Expected parse("C*07:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_590():
    result = parse("C*07:590")
    assert result.__class__ is Allele, f'Expected parse("C*07:590") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:590") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_591():
    result = parse("C*07:591")
    assert result.__class__ is Allele, f'Expected parse("C*07:591") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:591") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_592():
    result = parse("C*07:592")
    assert result.__class__ is Allele, f'Expected parse("C*07:592") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:592") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_593N():
    result = parse("C*07:593N")
    assert result.__class__ is Allele, f'Expected parse("C*07:593N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:593N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_594():
    result = parse("C*07:594")
    assert result.__class__ is Allele, f'Expected parse("C*07:594") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:594") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_595():
    result = parse("C*07:595")
    assert result.__class__ is Allele, f'Expected parse("C*07:595") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:595") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_596():
    result = parse("C*07:596")
    assert result.__class__ is Allele, f'Expected parse("C*07:596") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:596") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_597():
    result = parse("C*07:597")
    assert result.__class__ is Allele, f'Expected parse("C*07:597") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:597") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_598():
    result = parse("C*07:598")
    assert result.__class__ is Allele, f'Expected parse("C*07:598") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:598") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_599():
    result = parse("C*07:599")
    assert result.__class__ is Allele, f'Expected parse("C*07:599") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:599") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_60():
    result = parse("C*07:60")
    assert result.__class__ is Allele, f'Expected parse("C*07:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_600_01N():
    result = parse("C*07:600:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:600:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:600:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_600_02N():
    result = parse("C*07:600:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:600:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:600:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_601():
    result = parse("C*07:601")
    assert result.__class__ is Allele, f'Expected parse("C*07:601") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:601") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_602():
    result = parse("C*07:602")
    assert result.__class__ is Allele, f'Expected parse("C*07:602") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:602") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_603N():
    result = parse("C*07:603N")
    assert result.__class__ is Allele, f'Expected parse("C*07:603N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:603N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_604():
    result = parse("C*07:604")
    assert result.__class__ is Allele, f'Expected parse("C*07:604") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:604") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_605():
    result = parse("C*07:605")
    assert result.__class__ is Allele, f'Expected parse("C*07:605") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:605") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_606():
    result = parse("C*07:606")
    assert result.__class__ is Allele, f'Expected parse("C*07:606") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:606") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_607():
    result = parse("C*07:607")
    assert result.__class__ is Allele, f'Expected parse("C*07:607") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:607") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_608():
    result = parse("C*07:608")
    assert result.__class__ is Allele, f'Expected parse("C*07:608") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:608") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_609():
    result = parse("C*07:609")
    assert result.__class__ is Allele, f'Expected parse("C*07:609") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:609") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_610():
    result = parse("C*07:610")
    assert result.__class__ is Allele, f'Expected parse("C*07:610") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:610") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_611():
    result = parse("C*07:611")
    assert result.__class__ is Allele, f'Expected parse("C*07:611") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:611") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_612():
    result = parse("C*07:612")
    assert result.__class__ is Allele, f'Expected parse("C*07:612") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:612") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_613():
    result = parse("C*07:613")
    assert result.__class__ is Allele, f'Expected parse("C*07:613") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:613") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_614():
    result = parse("C*07:614")
    assert result.__class__ is Allele, f'Expected parse("C*07:614") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:614") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_615():
    result = parse("C*07:615")
    assert result.__class__ is Allele, f'Expected parse("C*07:615") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:615") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_616():
    result = parse("C*07:616")
    assert result.__class__ is Allele, f'Expected parse("C*07:616") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:616") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_617():
    result = parse("C*07:617")
    assert result.__class__ is Allele, f'Expected parse("C*07:617") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:617") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_618():
    result = parse("C*07:618")
    assert result.__class__ is Allele, f'Expected parse("C*07:618") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:618") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_619():
    result = parse("C*07:619")
    assert result.__class__ is Allele, f'Expected parse("C*07:619") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:619") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_61N():
    result = parse("C*07:61N")
    assert result.__class__ is Allele, f'Expected parse("C*07:61N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:61N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_62():
    result = parse("C*07:62")
    assert result.__class__ is Allele, f'Expected parse("C*07:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_620():
    result = parse("C*07:620")
    assert result.__class__ is Allele, f'Expected parse("C*07:620") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:620") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_621():
    result = parse("C*07:621")
    assert result.__class__ is Allele, f'Expected parse("C*07:621") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:621") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_622():
    result = parse("C*07:622")
    assert result.__class__ is Allele, f'Expected parse("C*07:622") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:622") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_623():
    result = parse("C*07:623")
    assert result.__class__ is Allele, f'Expected parse("C*07:623") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:623") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_624():
    result = parse("C*07:624")
    assert result.__class__ is Allele, f'Expected parse("C*07:624") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:624") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_625():
    result = parse("C*07:625")
    assert result.__class__ is Allele, f'Expected parse("C*07:625") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:625") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_626():
    result = parse("C*07:626")
    assert result.__class__ is Allele, f'Expected parse("C*07:626") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:626") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_627():
    result = parse("C*07:627")
    assert result.__class__ is Allele, f'Expected parse("C*07:627") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:627") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_628():
    result = parse("C*07:628")
    assert result.__class__ is Allele, f'Expected parse("C*07:628") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:628") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_629():
    result = parse("C*07:629")
    assert result.__class__ is Allele, f'Expected parse("C*07:629") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:629") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_63():
    result = parse("C*07:63")
    assert result.__class__ is Allele, f'Expected parse("C*07:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_630():
    result = parse("C*07:630")
    assert result.__class__ is Allele, f'Expected parse("C*07:630") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:630") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_631():
    result = parse("C*07:631")
    assert result.__class__ is Allele, f'Expected parse("C*07:631") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:631") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_632Q():
    result = parse("C*07:632Q")
    assert result.__class__ is Allele, f'Expected parse("C*07:632Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:632Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_633N():
    result = parse("C*07:633N")
    assert result.__class__ is Allele, f'Expected parse("C*07:633N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:633N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_634():
    result = parse("C*07:634")
    assert result.__class__ is Allele, f'Expected parse("C*07:634") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:634") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_635():
    result = parse("C*07:635")
    assert result.__class__ is Allele, f'Expected parse("C*07:635") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:635") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_636():
    result = parse("C*07:636")
    assert result.__class__ is Allele, f'Expected parse("C*07:636") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:636") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_637():
    result = parse("C*07:637")
    assert result.__class__ is Allele, f'Expected parse("C*07:637") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:637") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_638():
    result = parse("C*07:638")
    assert result.__class__ is Allele, f'Expected parse("C*07:638") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:638") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_639():
    result = parse("C*07:639")
    assert result.__class__ is Allele, f'Expected parse("C*07:639") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:639") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_64():
    result = parse("C*07:64")
    assert result.__class__ is Allele, f'Expected parse("C*07:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_640():
    result = parse("C*07:640")
    assert result.__class__ is Allele, f'Expected parse("C*07:640") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:640") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_641():
    result = parse("C*07:641")
    assert result.__class__ is Allele, f'Expected parse("C*07:641") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:641") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_642():
    result = parse("C*07:642")
    assert result.__class__ is Allele, f'Expected parse("C*07:642") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:642") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_643():
    result = parse("C*07:643")
    assert result.__class__ is Allele, f'Expected parse("C*07:643") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:643") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_644():
    result = parse("C*07:644")
    assert result.__class__ is Allele, f'Expected parse("C*07:644") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:644") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_645():
    result = parse("C*07:645")
    assert result.__class__ is Allele, f'Expected parse("C*07:645") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:645") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_646():
    result = parse("C*07:646")
    assert result.__class__ is Allele, f'Expected parse("C*07:646") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:646") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_647():
    result = parse("C*07:647")
    assert result.__class__ is Allele, f'Expected parse("C*07:647") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:647") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_648():
    result = parse("C*07:648")
    assert result.__class__ is Allele, f'Expected parse("C*07:648") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:648") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_649():
    result = parse("C*07:649")
    assert result.__class__ is Allele, f'Expected parse("C*07:649") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:649") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_65():
    result = parse("C*07:65")
    assert result.__class__ is Allele, f'Expected parse("C*07:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_650_01():
    result = parse("C*07:650:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:650:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:650:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_650_02():
    result = parse("C*07:650:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:650:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:650:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_651():
    result = parse("C*07:651")
    assert result.__class__ is Allele, f'Expected parse("C*07:651") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:651") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_652():
    result = parse("C*07:652")
    assert result.__class__ is Allele, f'Expected parse("C*07:652") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:652") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_653():
    result = parse("C*07:653")
    assert result.__class__ is Allele, f'Expected parse("C*07:653") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:653") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_654():
    result = parse("C*07:654")
    assert result.__class__ is Allele, f'Expected parse("C*07:654") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:654") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_655():
    result = parse("C*07:655")
    assert result.__class__ is Allele, f'Expected parse("C*07:655") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:655") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_656():
    result = parse("C*07:656")
    assert result.__class__ is Allele, f'Expected parse("C*07:656") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:656") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_657():
    result = parse("C*07:657")
    assert result.__class__ is Allele, f'Expected parse("C*07:657") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:657") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_658():
    result = parse("C*07:658")
    assert result.__class__ is Allele, f'Expected parse("C*07:658") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:658") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_659_01_01():
    result = parse("C*07:659:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:659:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:659:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_659_01_02():
    result = parse("C*07:659:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:659:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:659:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_66():
    result = parse("C*07:66")
    assert result.__class__ is Allele, f'Expected parse("C*07:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_660():
    result = parse("C*07:660")
    assert result.__class__ is Allele, f'Expected parse("C*07:660") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:660") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_661():
    result = parse("C*07:661")
    assert result.__class__ is Allele, f'Expected parse("C*07:661") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:661") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_662():
    result = parse("C*07:662")
    assert result.__class__ is Allele, f'Expected parse("C*07:662") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:662") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_663Q():
    result = parse("C*07:663Q")
    assert result.__class__ is Allele, f'Expected parse("C*07:663Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:663Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_664():
    result = parse("C*07:664")
    assert result.__class__ is Allele, f'Expected parse("C*07:664") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:664") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_665():
    result = parse("C*07:665")
    assert result.__class__ is Allele, f'Expected parse("C*07:665") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:665") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_666():
    result = parse("C*07:666")
    assert result.__class__ is Allele, f'Expected parse("C*07:666") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:666") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_667_01():
    result = parse("C*07:667:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:667:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:667:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_667_02():
    result = parse("C*07:667:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:667:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:667:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_668():
    result = parse("C*07:668")
    assert result.__class__ is Allele, f'Expected parse("C*07:668") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:668") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_669():
    result = parse("C*07:669")
    assert result.__class__ is Allele, f'Expected parse("C*07:669") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:669") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_67():
    result = parse("C*07:67")
    assert result.__class__ is Allele, f'Expected parse("C*07:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_670():
    result = parse("C*07:670")
    assert result.__class__ is Allele, f'Expected parse("C*07:670") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:670") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_671():
    result = parse("C*07:671")
    assert result.__class__ is Allele, f'Expected parse("C*07:671") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:671") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_672N():
    result = parse("C*07:672N")
    assert result.__class__ is Allele, f'Expected parse("C*07:672N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:672N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_673():
    result = parse("C*07:673")
    assert result.__class__ is Allele, f'Expected parse("C*07:673") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:673") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_674():
    result = parse("C*07:674")
    assert result.__class__ is Allele, f'Expected parse("C*07:674") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:674") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_675N():
    result = parse("C*07:675N")
    assert result.__class__ is Allele, f'Expected parse("C*07:675N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:675N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_676():
    result = parse("C*07:676")
    assert result.__class__ is Allele, f'Expected parse("C*07:676") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:676") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_677():
    result = parse("C*07:677")
    assert result.__class__ is Allele, f'Expected parse("C*07:677") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:677") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_678():
    result = parse("C*07:678")
    assert result.__class__ is Allele, f'Expected parse("C*07:678") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:678") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_679():
    result = parse("C*07:679")
    assert result.__class__ is Allele, f'Expected parse("C*07:679") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:679") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_68():
    result = parse("C*07:68")
    assert result.__class__ is Allele, f'Expected parse("C*07:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_680():
    result = parse("C*07:680")
    assert result.__class__ is Allele, f'Expected parse("C*07:680") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:680") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_681():
    result = parse("C*07:681")
    assert result.__class__ is Allele, f'Expected parse("C*07:681") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:681") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_682_01_01():
    result = parse("C*07:682:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:682:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:682:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_682_01_02():
    result = parse("C*07:682:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:682:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:682:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_682_02():
    result = parse("C*07:682:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:682:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:682:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_683():
    result = parse("C*07:683")
    assert result.__class__ is Allele, f'Expected parse("C*07:683") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:683") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_684():
    result = parse("C*07:684")
    assert result.__class__ is Allele, f'Expected parse("C*07:684") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:684") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_685():
    result = parse("C*07:685")
    assert result.__class__ is Allele, f'Expected parse("C*07:685") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:685") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_686N():
    result = parse("C*07:686N")
    assert result.__class__ is Allele, f'Expected parse("C*07:686N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:686N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_687():
    result = parse("C*07:687")
    assert result.__class__ is Allele, f'Expected parse("C*07:687") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:687") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_688():
    result = parse("C*07:688")
    assert result.__class__ is Allele, f'Expected parse("C*07:688") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:688") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_689():
    result = parse("C*07:689")
    assert result.__class__ is Allele, f'Expected parse("C*07:689") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:689") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_69():
    result = parse("C*07:69")
    assert result.__class__ is Allele, f'Expected parse("C*07:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_690N():
    result = parse("C*07:690N")
    assert result.__class__ is Allele, f'Expected parse("C*07:690N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:690N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_691():
    result = parse("C*07:691")
    assert result.__class__ is Allele, f'Expected parse("C*07:691") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:691") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_692():
    result = parse("C*07:692")
    assert result.__class__ is Allele, f'Expected parse("C*07:692") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:692") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_693():
    result = parse("C*07:693")
    assert result.__class__ is Allele, f'Expected parse("C*07:693") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:693") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_694():
    result = parse("C*07:694")
    assert result.__class__ is Allele, f'Expected parse("C*07:694") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:694") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_695_01_01():
    result = parse("C*07:695:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:695:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:695:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_695_01_02():
    result = parse("C*07:695:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:695:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:695:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_696():
    result = parse("C*07:696")
    assert result.__class__ is Allele, f'Expected parse("C*07:696") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:696") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_697Q():
    result = parse("C*07:697Q")
    assert result.__class__ is Allele, f'Expected parse("C*07:697Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:697Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_698():
    result = parse("C*07:698")
    assert result.__class__ is Allele, f'Expected parse("C*07:698") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:698") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_699():
    result = parse("C*07:699")
    assert result.__class__ is Allele, f'Expected parse("C*07:699") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:699") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_70():
    result = parse("C*07:70")
    assert result.__class__ is Allele, f'Expected parse("C*07:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_700():
    result = parse("C*07:700")
    assert result.__class__ is Allele, f'Expected parse("C*07:700") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:700") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_701():
    result = parse("C*07:701")
    assert result.__class__ is Allele, f'Expected parse("C*07:701") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:701") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_702N():
    result = parse("C*07:702N")
    assert result.__class__ is Allele, f'Expected parse("C*07:702N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:702N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_703():
    result = parse("C*07:703")
    assert result.__class__ is Allele, f'Expected parse("C*07:703") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:703") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_704():
    result = parse("C*07:704")
    assert result.__class__ is Allele, f'Expected parse("C*07:704") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:704") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_705():
    result = parse("C*07:705")
    assert result.__class__ is Allele, f'Expected parse("C*07:705") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:705") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_706():
    result = parse("C*07:706")
    assert result.__class__ is Allele, f'Expected parse("C*07:706") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:706") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_707():
    result = parse("C*07:707")
    assert result.__class__ is Allele, f'Expected parse("C*07:707") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:707") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_708():
    result = parse("C*07:708")
    assert result.__class__ is Allele, f'Expected parse("C*07:708") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:708") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_709():
    result = parse("C*07:709")
    assert result.__class__ is Allele, f'Expected parse("C*07:709") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:709") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_71():
    result = parse("C*07:71")
    assert result.__class__ is Allele, f'Expected parse("C*07:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_710():
    result = parse("C*07:710")
    assert result.__class__ is Allele, f'Expected parse("C*07:710") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:710") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_711():
    result = parse("C*07:711")
    assert result.__class__ is Allele, f'Expected parse("C*07:711") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:711") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_712():
    result = parse("C*07:712")
    assert result.__class__ is Allele, f'Expected parse("C*07:712") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:712") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_713Q():
    result = parse("C*07:713Q")
    assert result.__class__ is Allele, f'Expected parse("C*07:713Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:713Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_714():
    result = parse("C*07:714")
    assert result.__class__ is Allele, f'Expected parse("C*07:714") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:714") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_715_01():
    result = parse("C*07:715:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:715:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:715:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_715_02():
    result = parse("C*07:715:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:715:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:715:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_716():
    result = parse("C*07:716")
    assert result.__class__ is Allele, f'Expected parse("C*07:716") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:716") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_717():
    result = parse("C*07:717")
    assert result.__class__ is Allele, f'Expected parse("C*07:717") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:717") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_718():
    result = parse("C*07:718")
    assert result.__class__ is Allele, f'Expected parse("C*07:718") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:718") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_719():
    result = parse("C*07:719")
    assert result.__class__ is Allele, f'Expected parse("C*07:719") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:719") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_72():
    result = parse("C*07:72")
    assert result.__class__ is Allele, f'Expected parse("C*07:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_720():
    result = parse("C*07:720")
    assert result.__class__ is Allele, f'Expected parse("C*07:720") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:720") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_721():
    result = parse("C*07:721")
    assert result.__class__ is Allele, f'Expected parse("C*07:721") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:721") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_722():
    result = parse("C*07:722")
    assert result.__class__ is Allele, f'Expected parse("C*07:722") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:722") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_723():
    result = parse("C*07:723")
    assert result.__class__ is Allele, f'Expected parse("C*07:723") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:723") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_724():
    result = parse("C*07:724")
    assert result.__class__ is Allele, f'Expected parse("C*07:724") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:724") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_725():
    result = parse("C*07:725")
    assert result.__class__ is Allele, f'Expected parse("C*07:725") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:725") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_726N():
    result = parse("C*07:726N")
    assert result.__class__ is Allele, f'Expected parse("C*07:726N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:726N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_727():
    result = parse("C*07:727")
    assert result.__class__ is Allele, f'Expected parse("C*07:727") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:727") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_728():
    result = parse("C*07:728")
    assert result.__class__ is Allele, f'Expected parse("C*07:728") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:728") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_729_01_01():
    result = parse("C*07:729:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:729:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:729:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_729_01_02():
    result = parse("C*07:729:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:729:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:729:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_730():
    result = parse("C*07:730")
    assert result.__class__ is Allele, f'Expected parse("C*07:730") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:730") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_731():
    result = parse("C*07:731")
    assert result.__class__ is Allele, f'Expected parse("C*07:731") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:731") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_732():
    result = parse("C*07:732")
    assert result.__class__ is Allele, f'Expected parse("C*07:732") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:732") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_733N():
    result = parse("C*07:733N")
    assert result.__class__ is Allele, f'Expected parse("C*07:733N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:733N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_734():
    result = parse("C*07:734")
    assert result.__class__ is Allele, f'Expected parse("C*07:734") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:734") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_735():
    result = parse("C*07:735")
    assert result.__class__ is Allele, f'Expected parse("C*07:735") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:735") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_736_01_01():
    result = parse("C*07:736:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:736:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:736:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_736_01_02():
    result = parse("C*07:736:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*07:736:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*07:736:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_737():
    result = parse("C*07:737")
    assert result.__class__ is Allele, f'Expected parse("C*07:737") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:737") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_738():
    result = parse("C*07:738")
    assert result.__class__ is Allele, f'Expected parse("C*07:738") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:738") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_739():
    result = parse("C*07:739")
    assert result.__class__ is Allele, f'Expected parse("C*07:739") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:739") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_73_01():
    result = parse("C*07:73:01")
    assert result.__class__ is Allele, f'Expected parse("C*07:73:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:73:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_73_02():
    result = parse("C*07:73:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:73:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:73:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_74():
    result = parse("C*07:74")
    assert result.__class__ is Allele, f'Expected parse("C*07:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_740():
    result = parse("C*07:740")
    assert result.__class__ is Allele, f'Expected parse("C*07:740") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:740") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_741():
    result = parse("C*07:741")
    assert result.__class__ is Allele, f'Expected parse("C*07:741") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:741") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_742():
    result = parse("C*07:742")
    assert result.__class__ is Allele, f'Expected parse("C*07:742") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:742") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_743N():
    result = parse("C*07:743N")
    assert result.__class__ is Allele, f'Expected parse("C*07:743N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:743N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_744():
    result = parse("C*07:744")
    assert result.__class__ is Allele, f'Expected parse("C*07:744") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:744") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_745N():
    result = parse("C*07:745N")
    assert result.__class__ is Allele, f'Expected parse("C*07:745N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:745N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_746N():
    result = parse("C*07:746N")
    assert result.__class__ is Allele, f'Expected parse("C*07:746N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:746N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_747N():
    result = parse("C*07:747N")
    assert result.__class__ is Allele, f'Expected parse("C*07:747N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:747N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_748():
    result = parse("C*07:748")
    assert result.__class__ is Allele, f'Expected parse("C*07:748") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:748") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_749N():
    result = parse("C*07:749N")
    assert result.__class__ is Allele, f'Expected parse("C*07:749N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:749N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_75():
    result = parse("C*07:75")
    assert result.__class__ is Allele, f'Expected parse("C*07:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_750N():
    result = parse("C*07:750N")
    assert result.__class__ is Allele, f'Expected parse("C*07:750N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:750N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_751N():
    result = parse("C*07:751N")
    assert result.__class__ is Allele, f'Expected parse("C*07:751N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:751N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_752N():
    result = parse("C*07:752N")
    assert result.__class__ is Allele, f'Expected parse("C*07:752N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:752N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_753N():
    result = parse("C*07:753N")
    assert result.__class__ is Allele, f'Expected parse("C*07:753N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:753N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_754N():
    result = parse("C*07:754N")
    assert result.__class__ is Allele, f'Expected parse("C*07:754N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:754N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_755():
    result = parse("C*07:755")
    assert result.__class__ is Allele, f'Expected parse("C*07:755") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:755") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_756():
    result = parse("C*07:756")
    assert result.__class__ is Allele, f'Expected parse("C*07:756") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:756") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_757():
    result = parse("C*07:757")
    assert result.__class__ is Allele, f'Expected parse("C*07:757") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:757") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_758():
    result = parse("C*07:758")
    assert result.__class__ is Allele, f'Expected parse("C*07:758") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:758") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_759():
    result = parse("C*07:759")
    assert result.__class__ is Allele, f'Expected parse("C*07:759") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:759") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_760():
    result = parse("C*07:760")
    assert result.__class__ is Allele, f'Expected parse("C*07:760") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:760") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_761():
    result = parse("C*07:761")
    assert result.__class__ is Allele, f'Expected parse("C*07:761") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:761") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_762():
    result = parse("C*07:762")
    assert result.__class__ is Allele, f'Expected parse("C*07:762") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:762") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_763():
    result = parse("C*07:763")
    assert result.__class__ is Allele, f'Expected parse("C*07:763") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:763") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_764():
    result = parse("C*07:764")
    assert result.__class__ is Allele, f'Expected parse("C*07:764") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:764") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_765():
    result = parse("C*07:765")
    assert result.__class__ is Allele, f'Expected parse("C*07:765") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:765") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_766():
    result = parse("C*07:766")
    assert result.__class__ is Allele, f'Expected parse("C*07:766") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:766") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_767():
    result = parse("C*07:767")
    assert result.__class__ is Allele, f'Expected parse("C*07:767") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:767") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_768():
    result = parse("C*07:768")
    assert result.__class__ is Allele, f'Expected parse("C*07:768") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:768") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_769():
    result = parse("C*07:769")
    assert result.__class__ is Allele, f'Expected parse("C*07:769") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:769") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_76_01():
    result = parse("C*07:76:01")
    assert result.__class__ is Allele, f'Expected parse("C*07:76:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:76:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_76_02():
    result = parse("C*07:76:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:76:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:76:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_77():
    result = parse("C*07:77")
    assert result.__class__ is Allele, f'Expected parse("C*07:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_770N():
    result = parse("C*07:770N")
    assert result.__class__ is Allele, f'Expected parse("C*07:770N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:770N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_771():
    result = parse("C*07:771")
    assert result.__class__ is Allele, f'Expected parse("C*07:771") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:771") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_772():
    result = parse("C*07:772")
    assert result.__class__ is Allele, f'Expected parse("C*07:772") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:772") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_773N():
    result = parse("C*07:773N")
    assert result.__class__ is Allele, f'Expected parse("C*07:773N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:773N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_774():
    result = parse("C*07:774")
    assert result.__class__ is Allele, f'Expected parse("C*07:774") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:774") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_775():
    result = parse("C*07:775")
    assert result.__class__ is Allele, f'Expected parse("C*07:775") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:775") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_776N():
    result = parse("C*07:776N")
    assert result.__class__ is Allele, f'Expected parse("C*07:776N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:776N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_777():
    result = parse("C*07:777")
    assert result.__class__ is Allele, f'Expected parse("C*07:777") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:777") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_778():
    result = parse("C*07:778")
    assert result.__class__ is Allele, f'Expected parse("C*07:778") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:778") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_779():
    result = parse("C*07:779")
    assert result.__class__ is Allele, f'Expected parse("C*07:779") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:779") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_780():
    result = parse("C*07:780")
    assert result.__class__ is Allele, f'Expected parse("C*07:780") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:780") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_781():
    result = parse("C*07:781")
    assert result.__class__ is Allele, f'Expected parse("C*07:781") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:781") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_782():
    result = parse("C*07:782")
    assert result.__class__ is Allele, f'Expected parse("C*07:782") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:782") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_783():
    result = parse("C*07:783")
    assert result.__class__ is Allele, f'Expected parse("C*07:783") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:783") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_784():
    result = parse("C*07:784")
    assert result.__class__ is Allele, f'Expected parse("C*07:784") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:784") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_785():
    result = parse("C*07:785")
    assert result.__class__ is Allele, f'Expected parse("C*07:785") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:785") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_786():
    result = parse("C*07:786")
    assert result.__class__ is Allele, f'Expected parse("C*07:786") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:786") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_787N():
    result = parse("C*07:787N")
    assert result.__class__ is Allele, f'Expected parse("C*07:787N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:787N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_788():
    result = parse("C*07:788")
    assert result.__class__ is Allele, f'Expected parse("C*07:788") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:788") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_789():
    result = parse("C*07:789")
    assert result.__class__ is Allele, f'Expected parse("C*07:789") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:789") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_78_01():
    result = parse("C*07:78:01")
    assert result.__class__ is Allele, f'Expected parse("C*07:78:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:78:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_78_02():
    result = parse("C*07:78:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:78:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:78:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_79():
    result = parse("C*07:79")
    assert result.__class__ is Allele, f'Expected parse("C*07:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_790():
    result = parse("C*07:790")
    assert result.__class__ is Allele, f'Expected parse("C*07:790") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:790") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_791():
    result = parse("C*07:791")
    assert result.__class__ is Allele, f'Expected parse("C*07:791") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:791") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_792():
    result = parse("C*07:792")
    assert result.__class__ is Allele, f'Expected parse("C*07:792") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:792") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_793():
    result = parse("C*07:793")
    assert result.__class__ is Allele, f'Expected parse("C*07:793") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:793") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_794():
    result = parse("C*07:794")
    assert result.__class__ is Allele, f'Expected parse("C*07:794") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:794") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_795():
    result = parse("C*07:795")
    assert result.__class__ is Allele, f'Expected parse("C*07:795") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:795") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_796N():
    result = parse("C*07:796N")
    assert result.__class__ is Allele, f'Expected parse("C*07:796N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:796N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_797N():
    result = parse("C*07:797N")
    assert result.__class__ is Allele, f'Expected parse("C*07:797N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:797N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_798():
    result = parse("C*07:798")
    assert result.__class__ is Allele, f'Expected parse("C*07:798") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:798") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_799():
    result = parse("C*07:799")
    assert result.__class__ is Allele, f'Expected parse("C*07:799") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:799") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_80():
    result = parse("C*07:80")
    assert result.__class__ is Allele, f'Expected parse("C*07:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_800():
    result = parse("C*07:800")
    assert result.__class__ is Allele, f'Expected parse("C*07:800") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:800") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_801():
    result = parse("C*07:801")
    assert result.__class__ is Allele, f'Expected parse("C*07:801") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:801") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_802():
    result = parse("C*07:802")
    assert result.__class__ is Allele, f'Expected parse("C*07:802") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:802") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_803():
    result = parse("C*07:803")
    assert result.__class__ is Allele, f'Expected parse("C*07:803") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:803") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_804N():
    result = parse("C*07:804N")
    assert result.__class__ is Allele, f'Expected parse("C*07:804N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:804N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_805():
    result = parse("C*07:805")
    assert result.__class__ is Allele, f'Expected parse("C*07:805") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:805") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_806():
    result = parse("C*07:806")
    assert result.__class__ is Allele, f'Expected parse("C*07:806") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:806") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_807N():
    result = parse("C*07:807N")
    assert result.__class__ is Allele, f'Expected parse("C*07:807N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:807N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_808N():
    result = parse("C*07:808N")
    assert result.__class__ is Allele, f'Expected parse("C*07:808N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:808N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_809():
    result = parse("C*07:809")
    assert result.__class__ is Allele, f'Expected parse("C*07:809") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:809") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_81():
    result = parse("C*07:81")
    assert result.__class__ is Allele, f'Expected parse("C*07:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_810():
    result = parse("C*07:810")
    assert result.__class__ is Allele, f'Expected parse("C*07:810") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:810") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_811():
    result = parse("C*07:811")
    assert result.__class__ is Allele, f'Expected parse("C*07:811") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:811") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_812():
    result = parse("C*07:812")
    assert result.__class__ is Allele, f'Expected parse("C*07:812") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:812") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_813():
    result = parse("C*07:813")
    assert result.__class__ is Allele, f'Expected parse("C*07:813") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:813") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_814():
    result = parse("C*07:814")
    assert result.__class__ is Allele, f'Expected parse("C*07:814") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:814") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_815():
    result = parse("C*07:815")
    assert result.__class__ is Allele, f'Expected parse("C*07:815") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:815") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_816():
    result = parse("C*07:816")
    assert result.__class__ is Allele, f'Expected parse("C*07:816") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:816") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_817():
    result = parse("C*07:817")
    assert result.__class__ is Allele, f'Expected parse("C*07:817") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:817") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_818():
    result = parse("C*07:818")
    assert result.__class__ is Allele, f'Expected parse("C*07:818") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:818") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_819Q():
    result = parse("C*07:819Q")
    assert result.__class__ is Allele, f'Expected parse("C*07:819Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:819Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_82():
    result = parse("C*07:82")
    assert result.__class__ is Allele, f'Expected parse("C*07:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_820N():
    result = parse("C*07:820N")
    assert result.__class__ is Allele, f'Expected parse("C*07:820N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:820N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_821N():
    result = parse("C*07:821N")
    assert result.__class__ is Allele, f'Expected parse("C*07:821N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:821N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_822():
    result = parse("C*07:822")
    assert result.__class__ is Allele, f'Expected parse("C*07:822") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:822") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_823():
    result = parse("C*07:823")
    assert result.__class__ is Allele, f'Expected parse("C*07:823") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:823") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_824():
    result = parse("C*07:824")
    assert result.__class__ is Allele, f'Expected parse("C*07:824") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:824") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_825():
    result = parse("C*07:825")
    assert result.__class__ is Allele, f'Expected parse("C*07:825") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:825") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_826():
    result = parse("C*07:826")
    assert result.__class__ is Allele, f'Expected parse("C*07:826") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:826") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_827():
    result = parse("C*07:827")
    assert result.__class__ is Allele, f'Expected parse("C*07:827") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:827") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_828():
    result = parse("C*07:828")
    assert result.__class__ is Allele, f'Expected parse("C*07:828") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:828") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_829():
    result = parse("C*07:829")
    assert result.__class__ is Allele, f'Expected parse("C*07:829") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:829") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_83():
    result = parse("C*07:83")
    assert result.__class__ is Allele, f'Expected parse("C*07:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_830():
    result = parse("C*07:830")
    assert result.__class__ is Allele, f'Expected parse("C*07:830") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:830") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_831():
    result = parse("C*07:831")
    assert result.__class__ is Allele, f'Expected parse("C*07:831") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:831") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_832():
    result = parse("C*07:832")
    assert result.__class__ is Allele, f'Expected parse("C*07:832") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:832") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_833():
    result = parse("C*07:833")
    assert result.__class__ is Allele, f'Expected parse("C*07:833") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:833") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_834():
    result = parse("C*07:834")
    assert result.__class__ is Allele, f'Expected parse("C*07:834") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:834") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_835():
    result = parse("C*07:835")
    assert result.__class__ is Allele, f'Expected parse("C*07:835") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:835") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_836():
    result = parse("C*07:836")
    assert result.__class__ is Allele, f'Expected parse("C*07:836") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:836") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_837():
    result = parse("C*07:837")
    assert result.__class__ is Allele, f'Expected parse("C*07:837") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:837") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_838():
    result = parse("C*07:838")
    assert result.__class__ is Allele, f'Expected parse("C*07:838") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:838") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_839N():
    result = parse("C*07:839N")
    assert result.__class__ is Allele, f'Expected parse("C*07:839N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:839N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_84():
    result = parse("C*07:84")
    assert result.__class__ is Allele, f'Expected parse("C*07:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_840N():
    result = parse("C*07:840N")
    assert result.__class__ is Allele, f'Expected parse("C*07:840N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:840N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_841():
    result = parse("C*07:841")
    assert result.__class__ is Allele, f'Expected parse("C*07:841") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:841") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_842():
    result = parse("C*07:842")
    assert result.__class__ is Allele, f'Expected parse("C*07:842") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:842") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_843():
    result = parse("C*07:843")
    assert result.__class__ is Allele, f'Expected parse("C*07:843") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:843") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_844():
    result = parse("C*07:844")
    assert result.__class__ is Allele, f'Expected parse("C*07:844") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:844") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_845():
    result = parse("C*07:845")
    assert result.__class__ is Allele, f'Expected parse("C*07:845") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:845") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_846():
    result = parse("C*07:846")
    assert result.__class__ is Allele, f'Expected parse("C*07:846") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:846") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_847():
    result = parse("C*07:847")
    assert result.__class__ is Allele, f'Expected parse("C*07:847") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:847") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_848():
    result = parse("C*07:848")
    assert result.__class__ is Allele, f'Expected parse("C*07:848") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:848") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_849N():
    result = parse("C*07:849N")
    assert result.__class__ is Allele, f'Expected parse("C*07:849N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:849N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_85():
    result = parse("C*07:85")
    assert result.__class__ is Allele, f'Expected parse("C*07:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_850():
    result = parse("C*07:850")
    assert result.__class__ is Allele, f'Expected parse("C*07:850") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:850") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_851():
    result = parse("C*07:851")
    assert result.__class__ is Allele, f'Expected parse("C*07:851") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:851") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_852():
    result = parse("C*07:852")
    assert result.__class__ is Allele, f'Expected parse("C*07:852") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:852") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_853():
    result = parse("C*07:853")
    assert result.__class__ is Allele, f'Expected parse("C*07:853") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:853") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_854():
    result = parse("C*07:854")
    assert result.__class__ is Allele, f'Expected parse("C*07:854") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:854") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_855():
    result = parse("C*07:855")
    assert result.__class__ is Allele, f'Expected parse("C*07:855") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:855") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_856N():
    result = parse("C*07:856N")
    assert result.__class__ is Allele, f'Expected parse("C*07:856N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:856N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_857():
    result = parse("C*07:857")
    assert result.__class__ is Allele, f'Expected parse("C*07:857") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:857") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_858():
    result = parse("C*07:858")
    assert result.__class__ is Allele, f'Expected parse("C*07:858") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:858") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_859():
    result = parse("C*07:859")
    assert result.__class__ is Allele, f'Expected parse("C*07:859") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:859") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_86():
    result = parse("C*07:86")
    assert result.__class__ is Allele, f'Expected parse("C*07:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_860():
    result = parse("C*07:860")
    assert result.__class__ is Allele, f'Expected parse("C*07:860") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:860") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_861():
    result = parse("C*07:861")
    assert result.__class__ is Allele, f'Expected parse("C*07:861") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:861") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_862():
    result = parse("C*07:862")
    assert result.__class__ is Allele, f'Expected parse("C*07:862") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:862") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_863N():
    result = parse("C*07:863N")
    assert result.__class__ is Allele, f'Expected parse("C*07:863N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:863N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_864():
    result = parse("C*07:864")
    assert result.__class__ is Allele, f'Expected parse("C*07:864") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:864") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_865():
    result = parse("C*07:865")
    assert result.__class__ is Allele, f'Expected parse("C*07:865") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:865") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_866():
    result = parse("C*07:866")
    assert result.__class__ is Allele, f'Expected parse("C*07:866") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:866") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_867():
    result = parse("C*07:867")
    assert result.__class__ is Allele, f'Expected parse("C*07:867") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:867") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_868():
    result = parse("C*07:868")
    assert result.__class__ is Allele, f'Expected parse("C*07:868") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:868") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_869():
    result = parse("C*07:869")
    assert result.__class__ is Allele, f'Expected parse("C*07:869") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:869") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_87():
    result = parse("C*07:87")
    assert result.__class__ is Allele, f'Expected parse("C*07:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_870():
    result = parse("C*07:870")
    assert result.__class__ is Allele, f'Expected parse("C*07:870") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:870") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_871():
    result = parse("C*07:871")
    assert result.__class__ is Allele, f'Expected parse("C*07:871") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:871") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_872():
    result = parse("C*07:872")
    assert result.__class__ is Allele, f'Expected parse("C*07:872") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:872") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_873():
    result = parse("C*07:873")
    assert result.__class__ is Allele, f'Expected parse("C*07:873") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:873") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_874():
    result = parse("C*07:874")
    assert result.__class__ is Allele, f'Expected parse("C*07:874") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:874") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_875():
    result = parse("C*07:875")
    assert result.__class__ is Allele, f'Expected parse("C*07:875") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:875") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_876():
    result = parse("C*07:876")
    assert result.__class__ is Allele, f'Expected parse("C*07:876") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:876") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_877():
    result = parse("C*07:877")
    assert result.__class__ is Allele, f'Expected parse("C*07:877") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:877") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_878():
    result = parse("C*07:878")
    assert result.__class__ is Allele, f'Expected parse("C*07:878") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:878") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_879():
    result = parse("C*07:879")
    assert result.__class__ is Allele, f'Expected parse("C*07:879") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:879") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_88():
    result = parse("C*07:88")
    assert result.__class__ is Allele, f'Expected parse("C*07:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_880():
    result = parse("C*07:880")
    assert result.__class__ is Allele, f'Expected parse("C*07:880") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:880") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_89():
    result = parse("C*07:89")
    assert result.__class__ is Allele, f'Expected parse("C*07:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_90():
    result = parse("C*07:90")
    assert result.__class__ is Allele, f'Expected parse("C*07:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_91():
    result = parse("C*07:91")
    assert result.__class__ is Allele, f'Expected parse("C*07:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_92():
    result = parse("C*07:92")
    assert result.__class__ is Allele, f'Expected parse("C*07:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_93_01():
    result = parse("C*07:93:01")
    assert result.__class__ is Allele, f'Expected parse("C*07:93:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:93:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_93_02():
    result = parse("C*07:93:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:93:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:93:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_94():
    result = parse("C*07:94")
    assert result.__class__ is Allele, f'Expected parse("C*07:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_95():
    result = parse("C*07:95")
    assert result.__class__ is Allele, f'Expected parse("C*07:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_96_01():
    result = parse("C*07:96:01")
    assert result.__class__ is Allele, f'Expected parse("C*07:96:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:96:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_96_02():
    result = parse("C*07:96:02")
    assert result.__class__ is Allele, f'Expected parse("C*07:96:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*07:96:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_97():
    result = parse("C*07:97")
    assert result.__class__ is Allele, f'Expected parse("C*07:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_98N():
    result = parse("C*07:98N")
    assert result.__class__ is Allele, f'Expected parse("C*07:98N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:98N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_07_99():
    result = parse("C*07:99")
    assert result.__class__ is Allele, f'Expected parse("C*07:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*07:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_01_01():
    result = parse("C*08:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_01_02():
    result = parse("C*08:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_01_03():
    result = parse("C*08:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_01_04():
    result = parse("C*08:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_01_05():
    result = parse("C*08:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_01_06():
    result = parse("C*08:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_01_07():
    result = parse("C*08:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_01_08():
    result = parse("C*08:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_01_09():
    result = parse("C*08:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_01_10():
    result = parse("C*08:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_01_11():
    result = parse("C*08:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_01_12():
    result = parse("C*08:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_01_13():
    result = parse("C*08:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_02():
    result = parse("C*08:01:02")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_03():
    result = parse("C*08:01:03")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_04():
    result = parse("C*08:01:04")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_05():
    result = parse("C*08:01:05")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_06():
    result = parse("C*08:01:06")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_07():
    result = parse("C*08:01:07")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_08():
    result = parse("C*08:01:08")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_09():
    result = parse("C*08:01:09")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_10():
    result = parse("C*08:01:10")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_11():
    result = parse("C*08:01:11")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_12():
    result = parse("C*08:01:12")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_13():
    result = parse("C*08:01:13")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_14():
    result = parse("C*08:01:14")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_15():
    result = parse("C*08:01:15")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_16():
    result = parse("C*08:01:16")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_17():
    result = parse("C*08:01:17")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_18():
    result = parse("C*08:01:18")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_19():
    result = parse("C*08:01:19")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_20():
    result = parse("C*08:01:20")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_21():
    result = parse("C*08:01:21")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_22():
    result = parse("C*08:01:22")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_23():
    result = parse("C*08:01:23")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_24():
    result = parse("C*08:01:24")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_25():
    result = parse("C*08:01:25")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_26():
    result = parse("C*08:01:26")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_27():
    result = parse("C*08:01:27")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_28():
    result = parse("C*08:01:28")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_01_29():
    result = parse("C*08:01:29")
    assert result.__class__ is Allele, f'Expected parse("C*08:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_01():
    result = parse("C*08:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_02():
    result = parse("C*08:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_03():
    result = parse("C*08:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_04():
    result = parse("C*08:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_05():
    result = parse("C*08:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_06():
    result = parse("C*08:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_07():
    result = parse("C*08:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_08():
    result = parse("C*08:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_09():
    result = parse("C*08:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_10():
    result = parse("C*08:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_11():
    result = parse("C*08:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_12():
    result = parse("C*08:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_13():
    result = parse("C*08:02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_14():
    result = parse("C*08:02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_15():
    result = parse("C*08:02:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_16():
    result = parse("C*08:02:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_17():
    result = parse("C*08:02:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_18():
    result = parse("C*08:02:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_19():
    result = parse("C*08:02:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_20():
    result = parse("C*08:02:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_21():
    result = parse("C*08:02:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_22():
    result = parse("C*08:02:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_23():
    result = parse("C*08:02:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_24():
    result = parse("C*08:02:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_25():
    result = parse("C*08:02:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_26():
    result = parse("C*08:02:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_27():
    result = parse("C*08:02:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_01_28():
    result = parse("C*08:02:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:02:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:02:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_02():
    result = parse("C*08:02:02")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_03():
    result = parse("C*08:02:03")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_04():
    result = parse("C*08:02:04")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_05():
    result = parse("C*08:02:05")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_06():
    result = parse("C*08:02:06")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_07():
    result = parse("C*08:02:07")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_08():
    result = parse("C*08:02:08")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_09():
    result = parse("C*08:02:09")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_10():
    result = parse("C*08:02:10")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_11():
    result = parse("C*08:02:11")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_12():
    result = parse("C*08:02:12")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_13():
    result = parse("C*08:02:13")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_14():
    result = parse("C*08:02:14")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_15():
    result = parse("C*08:02:15")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_16():
    result = parse("C*08:02:16")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_17():
    result = parse("C*08:02:17")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_18():
    result = parse("C*08:02:18")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_19():
    result = parse("C*08:02:19")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_20():
    result = parse("C*08:02:20")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_21():
    result = parse("C*08:02:21")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_22():
    result = parse("C*08:02:22")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_23():
    result = parse("C*08:02:23")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_24():
    result = parse("C*08:02:24")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_25():
    result = parse("C*08:02:25")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_26():
    result = parse("C*08:02:26")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_27():
    result = parse("C*08:02:27")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_28():
    result = parse("C*08:02:28")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_29():
    result = parse("C*08:02:29")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_02_30():
    result = parse("C*08:02:30")
    assert result.__class__ is Allele, f'Expected parse("C*08:02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:02:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_03_01():
    result = parse("C*08:03:01")
    assert result.__class__ is Allele, f'Expected parse("C*08:03:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:03:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_03_02():
    result = parse("C*08:03:02")
    assert result.__class__ is Allele, f'Expected parse("C*08:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_03_03():
    result = parse("C*08:03:03")
    assert result.__class__ is Allele, f'Expected parse("C*08:03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_03_04():
    result = parse("C*08:03:04")
    assert result.__class__ is Allele, f'Expected parse("C*08:03:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_04_01_01():
    result = parse("C*08:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_04_01_02():
    result = parse("C*08:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_04_02():
    result = parse("C*08:04:02")
    assert result.__class__ is Allele, f'Expected parse("C*08:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_04_03():
    result = parse("C*08:04:03")
    assert result.__class__ is Allele, f'Expected parse("C*08:04:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_05():
    result = parse("C*08:05")
    assert result.__class__ is Allele, f'Expected parse("C*08:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_06():
    result = parse("C*08:06")
    assert result.__class__ is Allele, f'Expected parse("C*08:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_07():
    result = parse("C*08:07")
    assert result.__class__ is Allele, f'Expected parse("C*08:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_08_01():
    result = parse("C*08:08:01")
    assert result.__class__ is Allele, f'Expected parse("C*08:08:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:08:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_08_02():
    result = parse("C*08:08:02")
    assert result.__class__ is Allele, f'Expected parse("C*08:08:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:08:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_09():
    result = parse("C*08:09")
    assert result.__class__ is Allele, f'Expected parse("C*08:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_10():
    result = parse("C*08:10")
    assert result.__class__ is Allele, f'Expected parse("C*08:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_100():
    result = parse("C*08:100")
    assert result.__class__ is Allele, f'Expected parse("C*08:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_101():
    result = parse("C*08:101")
    assert result.__class__ is Allele, f'Expected parse("C*08:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_102():
    result = parse("C*08:102")
    assert result.__class__ is Allele, f'Expected parse("C*08:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_103():
    result = parse("C*08:103")
    assert result.__class__ is Allele, f'Expected parse("C*08:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_104():
    result = parse("C*08:104")
    assert result.__class__ is Allele, f'Expected parse("C*08:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_105():
    result = parse("C*08:105")
    assert result.__class__ is Allele, f'Expected parse("C*08:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_106():
    result = parse("C*08:106")
    assert result.__class__ is Allele, f'Expected parse("C*08:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_107():
    result = parse("C*08:107")
    assert result.__class__ is Allele, f'Expected parse("C*08:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_108():
    result = parse("C*08:108")
    assert result.__class__ is Allele, f'Expected parse("C*08:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_109():
    result = parse("C*08:109")
    assert result.__class__ is Allele, f'Expected parse("C*08:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_11():
    result = parse("C*08:11")
    assert result.__class__ is Allele, f'Expected parse("C*08:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_110():
    result = parse("C*08:110")
    assert result.__class__ is Allele, f'Expected parse("C*08:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_111():
    result = parse("C*08:111")
    assert result.__class__ is Allele, f'Expected parse("C*08:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_112():
    result = parse("C*08:112")
    assert result.__class__ is Allele, f'Expected parse("C*08:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_113():
    result = parse("C*08:113")
    assert result.__class__ is Allele, f'Expected parse("C*08:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_114():
    result = parse("C*08:114")
    assert result.__class__ is Allele, f'Expected parse("C*08:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_115():
    result = parse("C*08:115")
    assert result.__class__ is Allele, f'Expected parse("C*08:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_116():
    result = parse("C*08:116")
    assert result.__class__ is Allele, f'Expected parse("C*08:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_117():
    result = parse("C*08:117")
    assert result.__class__ is Allele, f'Expected parse("C*08:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_118():
    result = parse("C*08:118")
    assert result.__class__ is Allele, f'Expected parse("C*08:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_119():
    result = parse("C*08:119")
    assert result.__class__ is Allele, f'Expected parse("C*08:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_120():
    result = parse("C*08:120")
    assert result.__class__ is Allele, f'Expected parse("C*08:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_121N():
    result = parse("C*08:121N")
    assert result.__class__ is Allele, f'Expected parse("C*08:121N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:121N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_122():
    result = parse("C*08:122")
    assert result.__class__ is Allele, f'Expected parse("C*08:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_123():
    result = parse("C*08:123")
    assert result.__class__ is Allele, f'Expected parse("C*08:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_124():
    result = parse("C*08:124")
    assert result.__class__ is Allele, f'Expected parse("C*08:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_125():
    result = parse("C*08:125")
    assert result.__class__ is Allele, f'Expected parse("C*08:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_126():
    result = parse("C*08:126")
    assert result.__class__ is Allele, f'Expected parse("C*08:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_127N():
    result = parse("C*08:127N")
    assert result.__class__ is Allele, f'Expected parse("C*08:127N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:127N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_128():
    result = parse("C*08:128")
    assert result.__class__ is Allele, f'Expected parse("C*08:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_129N():
    result = parse("C*08:129N")
    assert result.__class__ is Allele, f'Expected parse("C*08:129N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:129N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_12_01_01():
    result = parse("C*08:12:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:12:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:12:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_12_01_02():
    result = parse("C*08:12:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:12:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:12:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_13():
    result = parse("C*08:13")
    assert result.__class__ is Allele, f'Expected parse("C*08:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_130N():
    result = parse("C*08:130N")
    assert result.__class__ is Allele, f'Expected parse("C*08:130N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:130N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_131():
    result = parse("C*08:131")
    assert result.__class__ is Allele, f'Expected parse("C*08:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_132():
    result = parse("C*08:132")
    assert result.__class__ is Allele, f'Expected parse("C*08:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_133():
    result = parse("C*08:133")
    assert result.__class__ is Allele, f'Expected parse("C*08:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_134():
    result = parse("C*08:134")
    assert result.__class__ is Allele, f'Expected parse("C*08:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_135():
    result = parse("C*08:135")
    assert result.__class__ is Allele, f'Expected parse("C*08:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_136():
    result = parse("C*08:136")
    assert result.__class__ is Allele, f'Expected parse("C*08:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_137():
    result = parse("C*08:137")
    assert result.__class__ is Allele, f'Expected parse("C*08:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_138():
    result = parse("C*08:138")
    assert result.__class__ is Allele, f'Expected parse("C*08:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_139():
    result = parse("C*08:139")
    assert result.__class__ is Allele, f'Expected parse("C*08:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_14():
    result = parse("C*08:14")
    assert result.__class__ is Allele, f'Expected parse("C*08:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_140():
    result = parse("C*08:140")
    assert result.__class__ is Allele, f'Expected parse("C*08:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_141Q():
    result = parse("C*08:141Q")
    assert result.__class__ is Allele, f'Expected parse("C*08:141Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:141Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_142():
    result = parse("C*08:142")
    assert result.__class__ is Allele, f'Expected parse("C*08:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_143():
    result = parse("C*08:143")
    assert result.__class__ is Allele, f'Expected parse("C*08:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_144_01():
    result = parse("C*08:144:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:144:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:144:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_144_02():
    result = parse("C*08:144:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:144:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:144:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_145():
    result = parse("C*08:145")
    assert result.__class__ is Allele, f'Expected parse("C*08:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_146():
    result = parse("C*08:146")
    assert result.__class__ is Allele, f'Expected parse("C*08:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_147():
    result = parse("C*08:147")
    assert result.__class__ is Allele, f'Expected parse("C*08:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_148():
    result = parse("C*08:148")
    assert result.__class__ is Allele, f'Expected parse("C*08:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_149():
    result = parse("C*08:149")
    assert result.__class__ is Allele, f'Expected parse("C*08:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_150():
    result = parse("C*08:150")
    assert result.__class__ is Allele, f'Expected parse("C*08:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_151():
    result = parse("C*08:151")
    assert result.__class__ is Allele, f'Expected parse("C*08:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_152():
    result = parse("C*08:152")
    assert result.__class__ is Allele, f'Expected parse("C*08:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_153():
    result = parse("C*08:153")
    assert result.__class__ is Allele, f'Expected parse("C*08:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_154():
    result = parse("C*08:154")
    assert result.__class__ is Allele, f'Expected parse("C*08:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_155():
    result = parse("C*08:155")
    assert result.__class__ is Allele, f'Expected parse("C*08:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_156():
    result = parse("C*08:156")
    assert result.__class__ is Allele, f'Expected parse("C*08:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_157():
    result = parse("C*08:157")
    assert result.__class__ is Allele, f'Expected parse("C*08:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_158():
    result = parse("C*08:158")
    assert result.__class__ is Allele, f'Expected parse("C*08:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_159():
    result = parse("C*08:159")
    assert result.__class__ is Allele, f'Expected parse("C*08:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_15_01():
    result = parse("C*08:15:01")
    assert result.__class__ is Allele, f'Expected parse("C*08:15:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:15:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_15_02():
    result = parse("C*08:15:02")
    assert result.__class__ is Allele, f'Expected parse("C*08:15:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:15:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_160():
    result = parse("C*08:160")
    assert result.__class__ is Allele, f'Expected parse("C*08:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_161N():
    result = parse("C*08:161N")
    assert result.__class__ is Allele, f'Expected parse("C*08:161N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:161N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_162():
    result = parse("C*08:162")
    assert result.__class__ is Allele, f'Expected parse("C*08:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_163():
    result = parse("C*08:163")
    assert result.__class__ is Allele, f'Expected parse("C*08:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_164():
    result = parse("C*08:164")
    assert result.__class__ is Allele, f'Expected parse("C*08:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_165():
    result = parse("C*08:165")
    assert result.__class__ is Allele, f'Expected parse("C*08:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_166():
    result = parse("C*08:166")
    assert result.__class__ is Allele, f'Expected parse("C*08:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_167():
    result = parse("C*08:167")
    assert result.__class__ is Allele, f'Expected parse("C*08:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_168():
    result = parse("C*08:168")
    assert result.__class__ is Allele, f'Expected parse("C*08:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_169():
    result = parse("C*08:169")
    assert result.__class__ is Allele, f'Expected parse("C*08:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_16_01():
    result = parse("C*08:16:01")
    assert result.__class__ is Allele, f'Expected parse("C*08:16:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:16:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_16_02():
    result = parse("C*08:16:02")
    assert result.__class__ is Allele, f'Expected parse("C*08:16:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:16:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_17():
    result = parse("C*08:17")
    assert result.__class__ is Allele, f'Expected parse("C*08:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_170():
    result = parse("C*08:170")
    assert result.__class__ is Allele, f'Expected parse("C*08:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_171():
    result = parse("C*08:171")
    assert result.__class__ is Allele, f'Expected parse("C*08:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_172():
    result = parse("C*08:172")
    assert result.__class__ is Allele, f'Expected parse("C*08:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_173N():
    result = parse("C*08:173N")
    assert result.__class__ is Allele, f'Expected parse("C*08:173N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:173N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_174():
    result = parse("C*08:174")
    assert result.__class__ is Allele, f'Expected parse("C*08:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_175():
    result = parse("C*08:175")
    assert result.__class__ is Allele, f'Expected parse("C*08:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_176():
    result = parse("C*08:176")
    assert result.__class__ is Allele, f'Expected parse("C*08:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_177():
    result = parse("C*08:177")
    assert result.__class__ is Allele, f'Expected parse("C*08:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_178():
    result = parse("C*08:178")
    assert result.__class__ is Allele, f'Expected parse("C*08:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_179():
    result = parse("C*08:179")
    assert result.__class__ is Allele, f'Expected parse("C*08:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_18():
    result = parse("C*08:18")
    assert result.__class__ is Allele, f'Expected parse("C*08:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_180N():
    result = parse("C*08:180N")
    assert result.__class__ is Allele, f'Expected parse("C*08:180N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:180N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_181N():
    result = parse("C*08:181N")
    assert result.__class__ is Allele, f'Expected parse("C*08:181N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:181N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_182():
    result = parse("C*08:182")
    assert result.__class__ is Allele, f'Expected parse("C*08:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_183():
    result = parse("C*08:183")
    assert result.__class__ is Allele, f'Expected parse("C*08:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_184():
    result = parse("C*08:184")
    assert result.__class__ is Allele, f'Expected parse("C*08:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_185():
    result = parse("C*08:185")
    assert result.__class__ is Allele, f'Expected parse("C*08:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_186():
    result = parse("C*08:186")
    assert result.__class__ is Allele, f'Expected parse("C*08:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_187():
    result = parse("C*08:187")
    assert result.__class__ is Allele, f'Expected parse("C*08:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_188():
    result = parse("C*08:188")
    assert result.__class__ is Allele, f'Expected parse("C*08:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_189():
    result = parse("C*08:189")
    assert result.__class__ is Allele, f'Expected parse("C*08:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_190():
    result = parse("C*08:190")
    assert result.__class__ is Allele, f'Expected parse("C*08:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_191():
    result = parse("C*08:191")
    assert result.__class__ is Allele, f'Expected parse("C*08:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_192():
    result = parse("C*08:192")
    assert result.__class__ is Allele, f'Expected parse("C*08:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_193():
    result = parse("C*08:193")
    assert result.__class__ is Allele, f'Expected parse("C*08:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_194():
    result = parse("C*08:194")
    assert result.__class__ is Allele, f'Expected parse("C*08:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_195():
    result = parse("C*08:195")
    assert result.__class__ is Allele, f'Expected parse("C*08:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_196():
    result = parse("C*08:196")
    assert result.__class__ is Allele, f'Expected parse("C*08:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_197():
    result = parse("C*08:197")
    assert result.__class__ is Allele, f'Expected parse("C*08:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_198():
    result = parse("C*08:198")
    assert result.__class__ is Allele, f'Expected parse("C*08:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_199():
    result = parse("C*08:199")
    assert result.__class__ is Allele, f'Expected parse("C*08:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_19_01():
    result = parse("C*08:19:01")
    assert result.__class__ is Allele, f'Expected parse("C*08:19:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:19:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_19_02():
    result = parse("C*08:19:02")
    assert result.__class__ is Allele, f'Expected parse("C*08:19:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:19:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_20():
    result = parse("C*08:20")
    assert result.__class__ is Allele, f'Expected parse("C*08:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_200():
    result = parse("C*08:200")
    assert result.__class__ is Allele, f'Expected parse("C*08:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_201():
    result = parse("C*08:201")
    assert result.__class__ is Allele, f'Expected parse("C*08:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_202():
    result = parse("C*08:202")
    assert result.__class__ is Allele, f'Expected parse("C*08:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_203():
    result = parse("C*08:203")
    assert result.__class__ is Allele, f'Expected parse("C*08:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_204():
    result = parse("C*08:204")
    assert result.__class__ is Allele, f'Expected parse("C*08:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_205():
    result = parse("C*08:205")
    assert result.__class__ is Allele, f'Expected parse("C*08:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_206():
    result = parse("C*08:206")
    assert result.__class__ is Allele, f'Expected parse("C*08:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_207():
    result = parse("C*08:207")
    assert result.__class__ is Allele, f'Expected parse("C*08:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_208N():
    result = parse("C*08:208N")
    assert result.__class__ is Allele, f'Expected parse("C*08:208N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:208N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_209():
    result = parse("C*08:209")
    assert result.__class__ is Allele, f'Expected parse("C*08:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_21():
    result = parse("C*08:21")
    assert result.__class__ is Allele, f'Expected parse("C*08:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_210():
    result = parse("C*08:210")
    assert result.__class__ is Allele, f'Expected parse("C*08:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_211():
    result = parse("C*08:211")
    assert result.__class__ is Allele, f'Expected parse("C*08:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_212():
    result = parse("C*08:212")
    assert result.__class__ is Allele, f'Expected parse("C*08:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_213():
    result = parse("C*08:213")
    assert result.__class__ is Allele, f'Expected parse("C*08:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_22_01_01():
    result = parse("C*08:22:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:22:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:22:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_22_01_02():
    result = parse("C*08:22:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*08:22:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*08:22:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_23():
    result = parse("C*08:23")
    assert result.__class__ is Allele, f'Expected parse("C*08:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_24():
    result = parse("C*08:24")
    assert result.__class__ is Allele, f'Expected parse("C*08:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_25():
    result = parse("C*08:25")
    assert result.__class__ is Allele, f'Expected parse("C*08:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_26N():
    result = parse("C*08:26N")
    assert result.__class__ is Allele, f'Expected parse("C*08:26N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:26N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_27():
    result = parse("C*08:27")
    assert result.__class__ is Allele, f'Expected parse("C*08:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_28():
    result = parse("C*08:28")
    assert result.__class__ is Allele, f'Expected parse("C*08:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_29():
    result = parse("C*08:29")
    assert result.__class__ is Allele, f'Expected parse("C*08:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_30():
    result = parse("C*08:30")
    assert result.__class__ is Allele, f'Expected parse("C*08:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_31():
    result = parse("C*08:31")
    assert result.__class__ is Allele, f'Expected parse("C*08:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_32():
    result = parse("C*08:32")
    assert result.__class__ is Allele, f'Expected parse("C*08:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_33_01():
    result = parse("C*08:33:01")
    assert result.__class__ is Allele, f'Expected parse("C*08:33:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:33:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_33_02():
    result = parse("C*08:33:02")
    assert result.__class__ is Allele, f'Expected parse("C*08:33:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:33:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_33_03():
    result = parse("C*08:33:03")
    assert result.__class__ is Allele, f'Expected parse("C*08:33:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:33:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_33_04():
    result = parse("C*08:33:04")
    assert result.__class__ is Allele, f'Expected parse("C*08:33:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:33:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_34():
    result = parse("C*08:34")
    assert result.__class__ is Allele, f'Expected parse("C*08:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_35():
    result = parse("C*08:35")
    assert result.__class__ is Allele, f'Expected parse("C*08:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_36N():
    result = parse("C*08:36N")
    assert result.__class__ is Allele, f'Expected parse("C*08:36N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:36N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_37():
    result = parse("C*08:37")
    assert result.__class__ is Allele, f'Expected parse("C*08:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_38():
    result = parse("C*08:38")
    assert result.__class__ is Allele, f'Expected parse("C*08:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_39():
    result = parse("C*08:39")
    assert result.__class__ is Allele, f'Expected parse("C*08:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_40():
    result = parse("C*08:40")
    assert result.__class__ is Allele, f'Expected parse("C*08:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_41():
    result = parse("C*08:41")
    assert result.__class__ is Allele, f'Expected parse("C*08:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_42():
    result = parse("C*08:42")
    assert result.__class__ is Allele, f'Expected parse("C*08:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_43():
    result = parse("C*08:43")
    assert result.__class__ is Allele, f'Expected parse("C*08:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_44():
    result = parse("C*08:44")
    assert result.__class__ is Allele, f'Expected parse("C*08:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_45():
    result = parse("C*08:45")
    assert result.__class__ is Allele, f'Expected parse("C*08:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_46():
    result = parse("C*08:46")
    assert result.__class__ is Allele, f'Expected parse("C*08:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_47():
    result = parse("C*08:47")
    assert result.__class__ is Allele, f'Expected parse("C*08:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_48():
    result = parse("C*08:48")
    assert result.__class__ is Allele, f'Expected parse("C*08:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_49():
    result = parse("C*08:49")
    assert result.__class__ is Allele, f'Expected parse("C*08:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_50():
    result = parse("C*08:50")
    assert result.__class__ is Allele, f'Expected parse("C*08:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_51():
    result = parse("C*08:51")
    assert result.__class__ is Allele, f'Expected parse("C*08:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_52N():
    result = parse("C*08:52N")
    assert result.__class__ is Allele, f'Expected parse("C*08:52N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:52N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_53():
    result = parse("C*08:53")
    assert result.__class__ is Allele, f'Expected parse("C*08:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_54():
    result = parse("C*08:54")
    assert result.__class__ is Allele, f'Expected parse("C*08:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_55N():
    result = parse("C*08:55N")
    assert result.__class__ is Allele, f'Expected parse("C*08:55N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:55N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_56():
    result = parse("C*08:56")
    assert result.__class__ is Allele, f'Expected parse("C*08:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_57():
    result = parse("C*08:57")
    assert result.__class__ is Allele, f'Expected parse("C*08:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_58():
    result = parse("C*08:58")
    assert result.__class__ is Allele, f'Expected parse("C*08:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_59():
    result = parse("C*08:59")
    assert result.__class__ is Allele, f'Expected parse("C*08:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_60():
    result = parse("C*08:60")
    assert result.__class__ is Allele, f'Expected parse("C*08:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_61():
    result = parse("C*08:61")
    assert result.__class__ is Allele, f'Expected parse("C*08:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_62_01():
    result = parse("C*08:62:01")
    assert result.__class__ is Allele, f'Expected parse("C*08:62:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:62:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_62_02():
    result = parse("C*08:62:02")
    assert result.__class__ is Allele, f'Expected parse("C*08:62:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:62:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_63():
    result = parse("C*08:63")
    assert result.__class__ is Allele, f'Expected parse("C*08:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_65():
    result = parse("C*08:65")
    assert result.__class__ is Allele, f'Expected parse("C*08:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_66():
    result = parse("C*08:66")
    assert result.__class__ is Allele, f'Expected parse("C*08:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_67():
    result = parse("C*08:67")
    assert result.__class__ is Allele, f'Expected parse("C*08:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_68():
    result = parse("C*08:68")
    assert result.__class__ is Allele, f'Expected parse("C*08:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_69():
    result = parse("C*08:69")
    assert result.__class__ is Allele, f'Expected parse("C*08:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_70Q():
    result = parse("C*08:70Q")
    assert result.__class__ is Allele, f'Expected parse("C*08:70Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:70Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_71():
    result = parse("C*08:71")
    assert result.__class__ is Allele, f'Expected parse("C*08:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_72_01():
    result = parse("C*08:72:01")
    assert result.__class__ is Allele, f'Expected parse("C*08:72:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:72:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_72_02():
    result = parse("C*08:72:02")
    assert result.__class__ is Allele, f'Expected parse("C*08:72:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*08:72:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_73():
    result = parse("C*08:73")
    assert result.__class__ is Allele, f'Expected parse("C*08:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_74():
    result = parse("C*08:74")
    assert result.__class__ is Allele, f'Expected parse("C*08:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_75():
    result = parse("C*08:75")
    assert result.__class__ is Allele, f'Expected parse("C*08:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_76():
    result = parse("C*08:76")
    assert result.__class__ is Allele, f'Expected parse("C*08:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_77():
    result = parse("C*08:77")
    assert result.__class__ is Allele, f'Expected parse("C*08:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_78():
    result = parse("C*08:78")
    assert result.__class__ is Allele, f'Expected parse("C*08:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_79():
    result = parse("C*08:79")
    assert result.__class__ is Allele, f'Expected parse("C*08:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_80():
    result = parse("C*08:80")
    assert result.__class__ is Allele, f'Expected parse("C*08:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_81():
    result = parse("C*08:81")
    assert result.__class__ is Allele, f'Expected parse("C*08:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_82():
    result = parse("C*08:82")
    assert result.__class__ is Allele, f'Expected parse("C*08:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_83():
    result = parse("C*08:83")
    assert result.__class__ is Allele, f'Expected parse("C*08:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_84():
    result = parse("C*08:84")
    assert result.__class__ is Allele, f'Expected parse("C*08:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_85():
    result = parse("C*08:85")
    assert result.__class__ is Allele, f'Expected parse("C*08:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_86():
    result = parse("C*08:86")
    assert result.__class__ is Allele, f'Expected parse("C*08:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_87():
    result = parse("C*08:87")
    assert result.__class__ is Allele, f'Expected parse("C*08:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_88N():
    result = parse("C*08:88N")
    assert result.__class__ is Allele, f'Expected parse("C*08:88N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:88N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_89N():
    result = parse("C*08:89N")
    assert result.__class__ is Allele, f'Expected parse("C*08:89N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:89N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_90():
    result = parse("C*08:90")
    assert result.__class__ is Allele, f'Expected parse("C*08:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_91():
    result = parse("C*08:91")
    assert result.__class__ is Allele, f'Expected parse("C*08:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_92():
    result = parse("C*08:92")
    assert result.__class__ is Allele, f'Expected parse("C*08:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_93():
    result = parse("C*08:93")
    assert result.__class__ is Allele, f'Expected parse("C*08:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_94():
    result = parse("C*08:94")
    assert result.__class__ is Allele, f'Expected parse("C*08:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_95():
    result = parse("C*08:95")
    assert result.__class__ is Allele, f'Expected parse("C*08:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_96():
    result = parse("C*08:96")
    assert result.__class__ is Allele, f'Expected parse("C*08:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_97():
    result = parse("C*08:97")
    assert result.__class__ is Allele, f'Expected parse("C*08:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_98():
    result = parse("C*08:98")
    assert result.__class__ is Allele, f'Expected parse("C*08:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_08_99():
    result = parse("C*08:99")
    assert result.__class__ is Allele, f'Expected parse("C*08:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*08:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_01():
    result = parse("C*12:02:01")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_02_01():
    result = parse("C*12:02:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:02:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:02:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_02_02():
    result = parse("C*12:02:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:02:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:02:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_02_03():
    result = parse("C*12:02:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:02:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:02:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_02_04():
    result = parse("C*12:02:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:02:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:02:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_02_05():
    result = parse("C*12:02:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:02:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:02:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_02_06():
    result = parse("C*12:02:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:02:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:02:02:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_02_07():
    result = parse("C*12:02:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:02:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:02:02:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_02_08():
    result = parse("C*12:02:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:02:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:02:02:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_02_09():
    result = parse("C*12:02:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:02:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:02:02:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_02_10():
    result = parse("C*12:02:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:02:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:02:02:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_02_11():
    result = parse("C*12:02:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:02:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:02:02:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_03():
    result = parse("C*12:02:03")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_04():
    result = parse("C*12:02:04")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_05():
    result = parse("C*12:02:05")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_06():
    result = parse("C*12:02:06")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_07():
    result = parse("C*12:02:07")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_08():
    result = parse("C*12:02:08")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_09():
    result = parse("C*12:02:09")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_10():
    result = parse("C*12:02:10")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_11():
    result = parse("C*12:02:11")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_12():
    result = parse("C*12:02:12")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_13():
    result = parse("C*12:02:13")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_14():
    result = parse("C*12:02:14")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_15():
    result = parse("C*12:02:15")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_16():
    result = parse("C*12:02:16")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_17():
    result = parse("C*12:02:17")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_18():
    result = parse("C*12:02:18")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_19():
    result = parse("C*12:02:19")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_20():
    result = parse("C*12:02:20")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_21():
    result = parse("C*12:02:21")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_22():
    result = parse("C*12:02:22")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_23():
    result = parse("C*12:02:23")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_24():
    result = parse("C*12:02:24")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_25():
    result = parse("C*12:02:25")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_26():
    result = parse("C*12:02:26")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_27():
    result = parse("C*12:02:27")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_28():
    result = parse("C*12:02:28")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_29():
    result = parse("C*12:02:29")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_30():
    result = parse("C*12:02:30")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_31():
    result = parse("C*12:02:31")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_32():
    result = parse("C*12:02:32")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_33():
    result = parse("C*12:02:33")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_34():
    result = parse("C*12:02:34")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_35():
    result = parse("C*12:02:35")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_36():
    result = parse("C*12:02:36")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_37():
    result = parse("C*12:02:37")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_02_38():
    result = parse("C*12:02:38")
    assert result.__class__ is Allele, f'Expected parse("C*12:02:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:02:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_01():
    result = parse("C*12:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_02():
    result = parse("C*12:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_03():
    result = parse("C*12:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_04():
    result = parse("C*12:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_05():
    result = parse("C*12:03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_06():
    result = parse("C*12:03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_07():
    result = parse("C*12:03:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_08():
    result = parse("C*12:03:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_09():
    result = parse("C*12:03:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_10():
    result = parse("C*12:03:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_11():
    result = parse("C*12:03:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_12():
    result = parse("C*12:03:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_13():
    result = parse("C*12:03:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_14():
    result = parse("C*12:03:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_15():
    result = parse("C*12:03:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_16():
    result = parse("C*12:03:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_17():
    result = parse("C*12:03:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_18():
    result = parse("C*12:03:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_19():
    result = parse("C*12:03:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_20():
    result = parse("C*12:03:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_21():
    result = parse("C*12:03:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_22():
    result = parse("C*12:03:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_23():
    result = parse("C*12:03:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_24():
    result = parse("C*12:03:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_25():
    result = parse("C*12:03:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_26():
    result = parse("C*12:03:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_27():
    result = parse("C*12:03:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_28():
    result = parse("C*12:03:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_29():
    result = parse("C*12:03:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_30():
    result = parse("C*12:03:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_31():
    result = parse("C*12:03:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_32():
    result = parse("C*12:03:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_33():
    result = parse("C*12:03:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_34():
    result = parse("C*12:03:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_35():
    result = parse("C*12:03:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_01_36():
    result = parse("C*12:03:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_02():
    result = parse("C*12:03:02")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_03():
    result = parse("C*12:03:03")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_04():
    result = parse("C*12:03:04")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_05():
    result = parse("C*12:03:05")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_06():
    result = parse("C*12:03:06")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_07():
    result = parse("C*12:03:07")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_08():
    result = parse("C*12:03:08")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_09():
    result = parse("C*12:03:09")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_10():
    result = parse("C*12:03:10")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_11():
    result = parse("C*12:03:11")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_12():
    result = parse("C*12:03:12")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_13():
    result = parse("C*12:03:13")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_14():
    result = parse("C*12:03:14")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_15():
    result = parse("C*12:03:15")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_16():
    result = parse("C*12:03:16")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_17():
    result = parse("C*12:03:17")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_18():
    result = parse("C*12:03:18")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_19():
    result = parse("C*12:03:19")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_20():
    result = parse("C*12:03:20")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_21():
    result = parse("C*12:03:21")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_22():
    result = parse("C*12:03:22")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_23():
    result = parse("C*12:03:23")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_24():
    result = parse("C*12:03:24")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_25():
    result = parse("C*12:03:25")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_26():
    result = parse("C*12:03:26")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_27():
    result = parse("C*12:03:27")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_28():
    result = parse("C*12:03:28")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_29():
    result = parse("C*12:03:29")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_30():
    result = parse("C*12:03:30")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_31():
    result = parse("C*12:03:31")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_32():
    result = parse("C*12:03:32")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_33():
    result = parse("C*12:03:33")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_34_01():
    result = parse("C*12:03:34:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:34:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:34:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_34_02():
    result = parse("C*12:03:34:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:03:34:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:03:34:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_35():
    result = parse("C*12:03:35")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_36():
    result = parse("C*12:03:36")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_37():
    result = parse("C*12:03:37")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_38():
    result = parse("C*12:03:38")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_39():
    result = parse("C*12:03:39")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_40():
    result = parse("C*12:03:40")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_41():
    result = parse("C*12:03:41")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_42():
    result = parse("C*12:03:42")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_43():
    result = parse("C*12:03:43")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_44():
    result = parse("C*12:03:44")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_45():
    result = parse("C*12:03:45")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_46():
    result = parse("C*12:03:46")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:46") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_47():
    result = parse("C*12:03:47")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:47") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_48():
    result = parse("C*12:03:48")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:48") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_49():
    result = parse("C*12:03:49")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:49") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_50():
    result = parse("C*12:03:50")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:50") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_51():
    result = parse("C*12:03:51")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:51") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_52():
    result = parse("C*12:03:52")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:52") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_53():
    result = parse("C*12:03:53")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:53") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_54():
    result = parse("C*12:03:54")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:54") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_55():
    result = parse("C*12:03:55")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:55") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_56():
    result = parse("C*12:03:56")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:56") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_57():
    result = parse("C*12:03:57")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:57") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_58():
    result = parse("C*12:03:58")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:58") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:58") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_59():
    result = parse("C*12:03:59")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:59") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:59") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_60():
    result = parse("C*12:03:60")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:60") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:60") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_61():
    result = parse("C*12:03:61")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:61") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:61") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_62():
    result = parse("C*12:03:62")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:62") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:62") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_63():
    result = parse("C*12:03:63")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:63") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:63") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_64():
    result = parse("C*12:03:64")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:64") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:64") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_03_65():
    result = parse("C*12:03:65")
    assert result.__class__ is Allele, f'Expected parse("C*12:03:65") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:03:65") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_04_01():
    result = parse("C*12:04:01")
    assert result.__class__ is Allele, f'Expected parse("C*12:04:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_04_02_01():
    result = parse("C*12:04:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:04:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:04:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_04_02_02():
    result = parse("C*12:04:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:04:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:04:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_05():
    result = parse("C*12:05")
    assert result.__class__ is Allele, f'Expected parse("C*12:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_06():
    result = parse("C*12:06")
    assert result.__class__ is Allele, f'Expected parse("C*12:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_07():
    result = parse("C*12:07")
    assert result.__class__ is Allele, f'Expected parse("C*12:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_08():
    result = parse("C*12:08")
    assert result.__class__ is Allele, f'Expected parse("C*12:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_09():
    result = parse("C*12:09")
    assert result.__class__ is Allele, f'Expected parse("C*12:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_100():
    result = parse("C*12:100")
    assert result.__class__ is Allele, f'Expected parse("C*12:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_101():
    result = parse("C*12:101")
    assert result.__class__ is Allele, f'Expected parse("C*12:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_102():
    result = parse("C*12:102")
    assert result.__class__ is Allele, f'Expected parse("C*12:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_103():
    result = parse("C*12:103")
    assert result.__class__ is Allele, f'Expected parse("C*12:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_104N():
    result = parse("C*12:104N")
    assert result.__class__ is Allele, f'Expected parse("C*12:104N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:104N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_105N():
    result = parse("C*12:105N")
    assert result.__class__ is Allele, f'Expected parse("C*12:105N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:105N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_106():
    result = parse("C*12:106")
    assert result.__class__ is Allele, f'Expected parse("C*12:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_107():
    result = parse("C*12:107")
    assert result.__class__ is Allele, f'Expected parse("C*12:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_108():
    result = parse("C*12:108")
    assert result.__class__ is Allele, f'Expected parse("C*12:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_109():
    result = parse("C*12:109")
    assert result.__class__ is Allele, f'Expected parse("C*12:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_10_01():
    result = parse("C*12:10:01")
    assert result.__class__ is Allele, f'Expected parse("C*12:10:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:10:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_10_02():
    result = parse("C*12:10:02")
    assert result.__class__ is Allele, f'Expected parse("C*12:10:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:10:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_11():
    result = parse("C*12:11")
    assert result.__class__ is Allele, f'Expected parse("C*12:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_110():
    result = parse("C*12:110")
    assert result.__class__ is Allele, f'Expected parse("C*12:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_111():
    result = parse("C*12:111")
    assert result.__class__ is Allele, f'Expected parse("C*12:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_112():
    result = parse("C*12:112")
    assert result.__class__ is Allele, f'Expected parse("C*12:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_113():
    result = parse("C*12:113")
    assert result.__class__ is Allele, f'Expected parse("C*12:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_114():
    result = parse("C*12:114")
    assert result.__class__ is Allele, f'Expected parse("C*12:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_115():
    result = parse("C*12:115")
    assert result.__class__ is Allele, f'Expected parse("C*12:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_116():
    result = parse("C*12:116")
    assert result.__class__ is Allele, f'Expected parse("C*12:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_117():
    result = parse("C*12:117")
    assert result.__class__ is Allele, f'Expected parse("C*12:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_118():
    result = parse("C*12:118")
    assert result.__class__ is Allele, f'Expected parse("C*12:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_119():
    result = parse("C*12:119")
    assert result.__class__ is Allele, f'Expected parse("C*12:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_12():
    result = parse("C*12:12")
    assert result.__class__ is Allele, f'Expected parse("C*12:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_120():
    result = parse("C*12:120")
    assert result.__class__ is Allele, f'Expected parse("C*12:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_121():
    result = parse("C*12:121")
    assert result.__class__ is Allele, f'Expected parse("C*12:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_122():
    result = parse("C*12:122")
    assert result.__class__ is Allele, f'Expected parse("C*12:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_123():
    result = parse("C*12:123")
    assert result.__class__ is Allele, f'Expected parse("C*12:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_124():
    result = parse("C*12:124")
    assert result.__class__ is Allele, f'Expected parse("C*12:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_125():
    result = parse("C*12:125")
    assert result.__class__ is Allele, f'Expected parse("C*12:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_126():
    result = parse("C*12:126")
    assert result.__class__ is Allele, f'Expected parse("C*12:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_127():
    result = parse("C*12:127")
    assert result.__class__ is Allele, f'Expected parse("C*12:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_128():
    result = parse("C*12:128")
    assert result.__class__ is Allele, f'Expected parse("C*12:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_129():
    result = parse("C*12:129")
    assert result.__class__ is Allele, f'Expected parse("C*12:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_130():
    result = parse("C*12:130")
    assert result.__class__ is Allele, f'Expected parse("C*12:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_131():
    result = parse("C*12:131")
    assert result.__class__ is Allele, f'Expected parse("C*12:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_132():
    result = parse("C*12:132")
    assert result.__class__ is Allele, f'Expected parse("C*12:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_133():
    result = parse("C*12:133")
    assert result.__class__ is Allele, f'Expected parse("C*12:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_134():
    result = parse("C*12:134")
    assert result.__class__ is Allele, f'Expected parse("C*12:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_135():
    result = parse("C*12:135")
    assert result.__class__ is Allele, f'Expected parse("C*12:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_136():
    result = parse("C*12:136")
    assert result.__class__ is Allele, f'Expected parse("C*12:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_137():
    result = parse("C*12:137")
    assert result.__class__ is Allele, f'Expected parse("C*12:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_138():
    result = parse("C*12:138")
    assert result.__class__ is Allele, f'Expected parse("C*12:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_139Q():
    result = parse("C*12:139Q")
    assert result.__class__ is Allele, f'Expected parse("C*12:139Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:139Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_13_01_01():
    result = parse("C*12:13:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:13:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:13:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_13_01_02():
    result = parse("C*12:13:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:13:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*12:13:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_140_01():
    result = parse("C*12:140:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:140:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:140:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_140_02():
    result = parse("C*12:140:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:140:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:140:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_141():
    result = parse("C*12:141")
    assert result.__class__ is Allele, f'Expected parse("C*12:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_142():
    result = parse("C*12:142")
    assert result.__class__ is Allele, f'Expected parse("C*12:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_143():
    result = parse("C*12:143")
    assert result.__class__ is Allele, f'Expected parse("C*12:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_144():
    result = parse("C*12:144")
    assert result.__class__ is Allele, f'Expected parse("C*12:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_145():
    result = parse("C*12:145")
    assert result.__class__ is Allele, f'Expected parse("C*12:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_146():
    result = parse("C*12:146")
    assert result.__class__ is Allele, f'Expected parse("C*12:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_147():
    result = parse("C*12:147")
    assert result.__class__ is Allele, f'Expected parse("C*12:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_148N():
    result = parse("C*12:148N")
    assert result.__class__ is Allele, f'Expected parse("C*12:148N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:148N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_149():
    result = parse("C*12:149")
    assert result.__class__ is Allele, f'Expected parse("C*12:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_14_01():
    result = parse("C*12:14:01")
    assert result.__class__ is Allele, f'Expected parse("C*12:14:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:14:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_14_02():
    result = parse("C*12:14:02")
    assert result.__class__ is Allele, f'Expected parse("C*12:14:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:14:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_15():
    result = parse("C*12:15")
    assert result.__class__ is Allele, f'Expected parse("C*12:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_150():
    result = parse("C*12:150")
    assert result.__class__ is Allele, f'Expected parse("C*12:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_151():
    result = parse("C*12:151")
    assert result.__class__ is Allele, f'Expected parse("C*12:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_152():
    result = parse("C*12:152")
    assert result.__class__ is Allele, f'Expected parse("C*12:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_153():
    result = parse("C*12:153")
    assert result.__class__ is Allele, f'Expected parse("C*12:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_154():
    result = parse("C*12:154")
    assert result.__class__ is Allele, f'Expected parse("C*12:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_155Q():
    result = parse("C*12:155Q")
    assert result.__class__ is Allele, f'Expected parse("C*12:155Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:155Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_156():
    result = parse("C*12:156")
    assert result.__class__ is Allele, f'Expected parse("C*12:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_157():
    result = parse("C*12:157")
    assert result.__class__ is Allele, f'Expected parse("C*12:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_158():
    result = parse("C*12:158")
    assert result.__class__ is Allele, f'Expected parse("C*12:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_159():
    result = parse("C*12:159")
    assert result.__class__ is Allele, f'Expected parse("C*12:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_160():
    result = parse("C*12:160")
    assert result.__class__ is Allele, f'Expected parse("C*12:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_161():
    result = parse("C*12:161")
    assert result.__class__ is Allele, f'Expected parse("C*12:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_162():
    result = parse("C*12:162")
    assert result.__class__ is Allele, f'Expected parse("C*12:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_163():
    result = parse("C*12:163")
    assert result.__class__ is Allele, f'Expected parse("C*12:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_164():
    result = parse("C*12:164")
    assert result.__class__ is Allele, f'Expected parse("C*12:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_165():
    result = parse("C*12:165")
    assert result.__class__ is Allele, f'Expected parse("C*12:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_166():
    result = parse("C*12:166")
    assert result.__class__ is Allele, f'Expected parse("C*12:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_167():
    result = parse("C*12:167")
    assert result.__class__ is Allele, f'Expected parse("C*12:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_168():
    result = parse("C*12:168")
    assert result.__class__ is Allele, f'Expected parse("C*12:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_169():
    result = parse("C*12:169")
    assert result.__class__ is Allele, f'Expected parse("C*12:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_16_01():
    result = parse("C*12:16:01")
    assert result.__class__ is Allele, f'Expected parse("C*12:16:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:16:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_16_02():
    result = parse("C*12:16:02")
    assert result.__class__ is Allele, f'Expected parse("C*12:16:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:16:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_17():
    result = parse("C*12:17")
    assert result.__class__ is Allele, f'Expected parse("C*12:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_170():
    result = parse("C*12:170")
    assert result.__class__ is Allele, f'Expected parse("C*12:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_171():
    result = parse("C*12:171")
    assert result.__class__ is Allele, f'Expected parse("C*12:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_172():
    result = parse("C*12:172")
    assert result.__class__ is Allele, f'Expected parse("C*12:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_173():
    result = parse("C*12:173")
    assert result.__class__ is Allele, f'Expected parse("C*12:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_174():
    result = parse("C*12:174")
    assert result.__class__ is Allele, f'Expected parse("C*12:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_175():
    result = parse("C*12:175")
    assert result.__class__ is Allele, f'Expected parse("C*12:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_176():
    result = parse("C*12:176")
    assert result.__class__ is Allele, f'Expected parse("C*12:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_177():
    result = parse("C*12:177")
    assert result.__class__ is Allele, f'Expected parse("C*12:177") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_178():
    result = parse("C*12:178")
    assert result.__class__ is Allele, f'Expected parse("C*12:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_179():
    result = parse("C*12:179")
    assert result.__class__ is Allele, f'Expected parse("C*12:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_180():
    result = parse("C*12:180")
    assert result.__class__ is Allele, f'Expected parse("C*12:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_181():
    result = parse("C*12:181")
    assert result.__class__ is Allele, f'Expected parse("C*12:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_182():
    result = parse("C*12:182")
    assert result.__class__ is Allele, f'Expected parse("C*12:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_183():
    result = parse("C*12:183")
    assert result.__class__ is Allele, f'Expected parse("C*12:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_184():
    result = parse("C*12:184")
    assert result.__class__ is Allele, f'Expected parse("C*12:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_185():
    result = parse("C*12:185")
    assert result.__class__ is Allele, f'Expected parse("C*12:185") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_186():
    result = parse("C*12:186")
    assert result.__class__ is Allele, f'Expected parse("C*12:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_187():
    result = parse("C*12:187")
    assert result.__class__ is Allele, f'Expected parse("C*12:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_188():
    result = parse("C*12:188")
    assert result.__class__ is Allele, f'Expected parse("C*12:188") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_189():
    result = parse("C*12:189")
    assert result.__class__ is Allele, f'Expected parse("C*12:189") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_18_01():
    result = parse("C*12:18:01")
    assert result.__class__ is Allele, f'Expected parse("C*12:18:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:18:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_18_02():
    result = parse("C*12:18:02")
    assert result.__class__ is Allele, f'Expected parse("C*12:18:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:18:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_19():
    result = parse("C*12:19")
    assert result.__class__ is Allele, f'Expected parse("C*12:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_190():
    result = parse("C*12:190")
    assert result.__class__ is Allele, f'Expected parse("C*12:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_191():
    result = parse("C*12:191")
    assert result.__class__ is Allele, f'Expected parse("C*12:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_192():
    result = parse("C*12:192")
    assert result.__class__ is Allele, f'Expected parse("C*12:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_193():
    result = parse("C*12:193")
    assert result.__class__ is Allele, f'Expected parse("C*12:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_194():
    result = parse("C*12:194")
    assert result.__class__ is Allele, f'Expected parse("C*12:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_195_01():
    result = parse("C*12:195:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:195:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:195:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_195_02():
    result = parse("C*12:195:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:195:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:195:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_195_03():
    result = parse("C*12:195:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:195:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:195:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_196():
    result = parse("C*12:196")
    assert result.__class__ is Allele, f'Expected parse("C*12:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_197():
    result = parse("C*12:197")
    assert result.__class__ is Allele, f'Expected parse("C*12:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_198():
    result = parse("C*12:198")
    assert result.__class__ is Allele, f'Expected parse("C*12:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_199():
    result = parse("C*12:199")
    assert result.__class__ is Allele, f'Expected parse("C*12:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_20():
    result = parse("C*12:20")
    assert result.__class__ is Allele, f'Expected parse("C*12:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_200():
    result = parse("C*12:200")
    assert result.__class__ is Allele, f'Expected parse("C*12:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_201():
    result = parse("C*12:201")
    assert result.__class__ is Allele, f'Expected parse("C*12:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_202():
    result = parse("C*12:202")
    assert result.__class__ is Allele, f'Expected parse("C*12:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_203():
    result = parse("C*12:203")
    assert result.__class__ is Allele, f'Expected parse("C*12:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_204():
    result = parse("C*12:204")
    assert result.__class__ is Allele, f'Expected parse("C*12:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_205():
    result = parse("C*12:205")
    assert result.__class__ is Allele, f'Expected parse("C*12:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_206():
    result = parse("C*12:206")
    assert result.__class__ is Allele, f'Expected parse("C*12:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_207():
    result = parse("C*12:207")
    assert result.__class__ is Allele, f'Expected parse("C*12:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_208():
    result = parse("C*12:208")
    assert result.__class__ is Allele, f'Expected parse("C*12:208") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_209():
    result = parse("C*12:209")
    assert result.__class__ is Allele, f'Expected parse("C*12:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_21():
    result = parse("C*12:21")
    assert result.__class__ is Allele, f'Expected parse("C*12:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_210():
    result = parse("C*12:210")
    assert result.__class__ is Allele, f'Expected parse("C*12:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_211():
    result = parse("C*12:211")
    assert result.__class__ is Allele, f'Expected parse("C*12:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_212():
    result = parse("C*12:212")
    assert result.__class__ is Allele, f'Expected parse("C*12:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_213():
    result = parse("C*12:213")
    assert result.__class__ is Allele, f'Expected parse("C*12:213") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_214():
    result = parse("C*12:214")
    assert result.__class__ is Allele, f'Expected parse("C*12:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_215():
    result = parse("C*12:215")
    assert result.__class__ is Allele, f'Expected parse("C*12:215") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_216():
    result = parse("C*12:216")
    assert result.__class__ is Allele, f'Expected parse("C*12:216") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_217():
    result = parse("C*12:217")
    assert result.__class__ is Allele, f'Expected parse("C*12:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_218():
    result = parse("C*12:218")
    assert result.__class__ is Allele, f'Expected parse("C*12:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_219N():
    result = parse("C*12:219N")
    assert result.__class__ is Allele, f'Expected parse("C*12:219N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:219N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_22():
    result = parse("C*12:22")
    assert result.__class__ is Allele, f'Expected parse("C*12:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_220():
    result = parse("C*12:220")
    assert result.__class__ is Allele, f'Expected parse("C*12:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_221():
    result = parse("C*12:221")
    assert result.__class__ is Allele, f'Expected parse("C*12:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_222():
    result = parse("C*12:222")
    assert result.__class__ is Allele, f'Expected parse("C*12:222") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_223():
    result = parse("C*12:223")
    assert result.__class__ is Allele, f'Expected parse("C*12:223") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_224():
    result = parse("C*12:224")
    assert result.__class__ is Allele, f'Expected parse("C*12:224") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_225():
    result = parse("C*12:225")
    assert result.__class__ is Allele, f'Expected parse("C*12:225") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_226():
    result = parse("C*12:226")
    assert result.__class__ is Allele, f'Expected parse("C*12:226") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_227():
    result = parse("C*12:227")
    assert result.__class__ is Allele, f'Expected parse("C*12:227") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_228():
    result = parse("C*12:228")
    assert result.__class__ is Allele, f'Expected parse("C*12:228") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_229():
    result = parse("C*12:229")
    assert result.__class__ is Allele, f'Expected parse("C*12:229") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_23():
    result = parse("C*12:23")
    assert result.__class__ is Allele, f'Expected parse("C*12:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_230():
    result = parse("C*12:230")
    assert result.__class__ is Allele, f'Expected parse("C*12:230") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_231():
    result = parse("C*12:231")
    assert result.__class__ is Allele, f'Expected parse("C*12:231") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_232N():
    result = parse("C*12:232N")
    assert result.__class__ is Allele, f'Expected parse("C*12:232N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:232N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_233():
    result = parse("C*12:233")
    assert result.__class__ is Allele, f'Expected parse("C*12:233") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_234():
    result = parse("C*12:234")
    assert result.__class__ is Allele, f'Expected parse("C*12:234") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_235():
    result = parse("C*12:235")
    assert result.__class__ is Allele, f'Expected parse("C*12:235") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_236N():
    result = parse("C*12:236N")
    assert result.__class__ is Allele, f'Expected parse("C*12:236N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:236N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_237():
    result = parse("C*12:237")
    assert result.__class__ is Allele, f'Expected parse("C*12:237") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_238():
    result = parse("C*12:238")
    assert result.__class__ is Allele, f'Expected parse("C*12:238") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_239():
    result = parse("C*12:239")
    assert result.__class__ is Allele, f'Expected parse("C*12:239") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_24():
    result = parse("C*12:24")
    assert result.__class__ is Allele, f'Expected parse("C*12:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_240():
    result = parse("C*12:240")
    assert result.__class__ is Allele, f'Expected parse("C*12:240") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_241():
    result = parse("C*12:241")
    assert result.__class__ is Allele, f'Expected parse("C*12:241") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_242():
    result = parse("C*12:242")
    assert result.__class__ is Allele, f'Expected parse("C*12:242") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_243():
    result = parse("C*12:243")
    assert result.__class__ is Allele, f'Expected parse("C*12:243") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_244():
    result = parse("C*12:244")
    assert result.__class__ is Allele, f'Expected parse("C*12:244") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_245():
    result = parse("C*12:245")
    assert result.__class__ is Allele, f'Expected parse("C*12:245") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_246():
    result = parse("C*12:246")
    assert result.__class__ is Allele, f'Expected parse("C*12:246") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_247():
    result = parse("C*12:247")
    assert result.__class__ is Allele, f'Expected parse("C*12:247") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_248():
    result = parse("C*12:248")
    assert result.__class__ is Allele, f'Expected parse("C*12:248") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_249():
    result = parse("C*12:249")
    assert result.__class__ is Allele, f'Expected parse("C*12:249") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_25():
    result = parse("C*12:25")
    assert result.__class__ is Allele, f'Expected parse("C*12:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_250():
    result = parse("C*12:250")
    assert result.__class__ is Allele, f'Expected parse("C*12:250") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_251():
    result = parse("C*12:251")
    assert result.__class__ is Allele, f'Expected parse("C*12:251") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_252():
    result = parse("C*12:252")
    assert result.__class__ is Allele, f'Expected parse("C*12:252") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_253():
    result = parse("C*12:253")
    assert result.__class__ is Allele, f'Expected parse("C*12:253") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_254():
    result = parse("C*12:254")
    assert result.__class__ is Allele, f'Expected parse("C*12:254") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_255():
    result = parse("C*12:255")
    assert result.__class__ is Allele, f'Expected parse("C*12:255") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_256():
    result = parse("C*12:256")
    assert result.__class__ is Allele, f'Expected parse("C*12:256") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_257():
    result = parse("C*12:257")
    assert result.__class__ is Allele, f'Expected parse("C*12:257") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_258():
    result = parse("C*12:258")
    assert result.__class__ is Allele, f'Expected parse("C*12:258") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_259():
    result = parse("C*12:259")
    assert result.__class__ is Allele, f'Expected parse("C*12:259") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_26():
    result = parse("C*12:26")
    assert result.__class__ is Allele, f'Expected parse("C*12:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_260_01():
    result = parse("C*12:260:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:260:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:260:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_260_02():
    result = parse("C*12:260:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:260:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:260:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_261():
    result = parse("C*12:261")
    assert result.__class__ is Allele, f'Expected parse("C*12:261") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_262():
    result = parse("C*12:262")
    assert result.__class__ is Allele, f'Expected parse("C*12:262") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_263():
    result = parse("C*12:263")
    assert result.__class__ is Allele, f'Expected parse("C*12:263") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_264():
    result = parse("C*12:264")
    assert result.__class__ is Allele, f'Expected parse("C*12:264") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_265():
    result = parse("C*12:265")
    assert result.__class__ is Allele, f'Expected parse("C*12:265") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_266():
    result = parse("C*12:266")
    assert result.__class__ is Allele, f'Expected parse("C*12:266") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_267():
    result = parse("C*12:267")
    assert result.__class__ is Allele, f'Expected parse("C*12:267") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_268():
    result = parse("C*12:268")
    assert result.__class__ is Allele, f'Expected parse("C*12:268") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_269():
    result = parse("C*12:269")
    assert result.__class__ is Allele, f'Expected parse("C*12:269") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_27():
    result = parse("C*12:27")
    assert result.__class__ is Allele, f'Expected parse("C*12:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_270N():
    result = parse("C*12:270N")
    assert result.__class__ is Allele, f'Expected parse("C*12:270N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:270N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_271():
    result = parse("C*12:271")
    assert result.__class__ is Allele, f'Expected parse("C*12:271") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_272():
    result = parse("C*12:272")
    assert result.__class__ is Allele, f'Expected parse("C*12:272") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_273():
    result = parse("C*12:273")
    assert result.__class__ is Allele, f'Expected parse("C*12:273") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_274_01N():
    result = parse("C*12:274:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:274:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:274:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_274_02N():
    result = parse("C*12:274:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*12:274:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:274:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_275():
    result = parse("C*12:275")
    assert result.__class__ is Allele, f'Expected parse("C*12:275") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_276():
    result = parse("C*12:276")
    assert result.__class__ is Allele, f'Expected parse("C*12:276") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_277():
    result = parse("C*12:277")
    assert result.__class__ is Allele, f'Expected parse("C*12:277") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_278():
    result = parse("C*12:278")
    assert result.__class__ is Allele, f'Expected parse("C*12:278") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_279():
    result = parse("C*12:279")
    assert result.__class__ is Allele, f'Expected parse("C*12:279") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_28():
    result = parse("C*12:28")
    assert result.__class__ is Allele, f'Expected parse("C*12:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_280():
    result = parse("C*12:280")
    assert result.__class__ is Allele, f'Expected parse("C*12:280") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_281():
    result = parse("C*12:281")
    assert result.__class__ is Allele, f'Expected parse("C*12:281") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_282():
    result = parse("C*12:282")
    assert result.__class__ is Allele, f'Expected parse("C*12:282") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_283():
    result = parse("C*12:283")
    assert result.__class__ is Allele, f'Expected parse("C*12:283") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_284():
    result = parse("C*12:284")
    assert result.__class__ is Allele, f'Expected parse("C*12:284") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_285():
    result = parse("C*12:285")
    assert result.__class__ is Allele, f'Expected parse("C*12:285") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_286():
    result = parse("C*12:286")
    assert result.__class__ is Allele, f'Expected parse("C*12:286") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_287():
    result = parse("C*12:287")
    assert result.__class__ is Allele, f'Expected parse("C*12:287") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:287") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_288():
    result = parse("C*12:288")
    assert result.__class__ is Allele, f'Expected parse("C*12:288") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_289():
    result = parse("C*12:289")
    assert result.__class__ is Allele, f'Expected parse("C*12:289") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_29():
    result = parse("C*12:29")
    assert result.__class__ is Allele, f'Expected parse("C*12:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_290():
    result = parse("C*12:290")
    assert result.__class__ is Allele, f'Expected parse("C*12:290") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_291():
    result = parse("C*12:291")
    assert result.__class__ is Allele, f'Expected parse("C*12:291") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_292():
    result = parse("C*12:292")
    assert result.__class__ is Allele, f'Expected parse("C*12:292") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_293():
    result = parse("C*12:293")
    assert result.__class__ is Allele, f'Expected parse("C*12:293") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_294():
    result = parse("C*12:294")
    assert result.__class__ is Allele, f'Expected parse("C*12:294") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_295N():
    result = parse("C*12:295N")
    assert result.__class__ is Allele, f'Expected parse("C*12:295N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:295N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_296():
    result = parse("C*12:296")
    assert result.__class__ is Allele, f'Expected parse("C*12:296") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_297():
    result = parse("C*12:297")
    assert result.__class__ is Allele, f'Expected parse("C*12:297") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_298():
    result = parse("C*12:298")
    assert result.__class__ is Allele, f'Expected parse("C*12:298") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_30():
    result = parse("C*12:30")
    assert result.__class__ is Allele, f'Expected parse("C*12:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_300():
    result = parse("C*12:300")
    assert result.__class__ is Allele, f'Expected parse("C*12:300") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_301():
    result = parse("C*12:301")
    assert result.__class__ is Allele, f'Expected parse("C*12:301") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_302():
    result = parse("C*12:302")
    assert result.__class__ is Allele, f'Expected parse("C*12:302") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_303():
    result = parse("C*12:303")
    assert result.__class__ is Allele, f'Expected parse("C*12:303") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:303") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_304():
    result = parse("C*12:304")
    assert result.__class__ is Allele, f'Expected parse("C*12:304") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:304") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_305():
    result = parse("C*12:305")
    assert result.__class__ is Allele, f'Expected parse("C*12:305") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_306():
    result = parse("C*12:306")
    assert result.__class__ is Allele, f'Expected parse("C*12:306") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:306") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_307():
    result = parse("C*12:307")
    assert result.__class__ is Allele, f'Expected parse("C*12:307") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_308():
    result = parse("C*12:308")
    assert result.__class__ is Allele, f'Expected parse("C*12:308") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:308") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_309():
    result = parse("C*12:309")
    assert result.__class__ is Allele, f'Expected parse("C*12:309") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:309") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_310():
    result = parse("C*12:310")
    assert result.__class__ is Allele, f'Expected parse("C*12:310") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:310") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_311N():
    result = parse("C*12:311N")
    assert result.__class__ is Allele, f'Expected parse("C*12:311N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:311N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_312():
    result = parse("C*12:312")
    assert result.__class__ is Allele, f'Expected parse("C*12:312") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:312") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_313():
    result = parse("C*12:313")
    assert result.__class__ is Allele, f'Expected parse("C*12:313") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:313") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_314():
    result = parse("C*12:314")
    assert result.__class__ is Allele, f'Expected parse("C*12:314") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:314") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_315():
    result = parse("C*12:315")
    assert result.__class__ is Allele, f'Expected parse("C*12:315") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:315") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_316():
    result = parse("C*12:316")
    assert result.__class__ is Allele, f'Expected parse("C*12:316") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:316") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_317():
    result = parse("C*12:317")
    assert result.__class__ is Allele, f'Expected parse("C*12:317") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:317") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_318():
    result = parse("C*12:318")
    assert result.__class__ is Allele, f'Expected parse("C*12:318") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:318") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_319():
    result = parse("C*12:319")
    assert result.__class__ is Allele, f'Expected parse("C*12:319") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_31_01():
    result = parse("C*12:31:01")
    assert result.__class__ is Allele, f'Expected parse("C*12:31:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:31:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_31_02():
    result = parse("C*12:31:02")
    assert result.__class__ is Allele, f'Expected parse("C*12:31:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:31:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_32():
    result = parse("C*12:32")
    assert result.__class__ is Allele, f'Expected parse("C*12:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_320():
    result = parse("C*12:320")
    assert result.__class__ is Allele, f'Expected parse("C*12:320") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:320") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_321():
    result = parse("C*12:321")
    assert result.__class__ is Allele, f'Expected parse("C*12:321") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:321") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_322():
    result = parse("C*12:322")
    assert result.__class__ is Allele, f'Expected parse("C*12:322") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:322") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_323():
    result = parse("C*12:323")
    assert result.__class__ is Allele, f'Expected parse("C*12:323") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:323") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_324N():
    result = parse("C*12:324N")
    assert result.__class__ is Allele, f'Expected parse("C*12:324N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:324N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_33():
    result = parse("C*12:33")
    assert result.__class__ is Allele, f'Expected parse("C*12:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_34():
    result = parse("C*12:34")
    assert result.__class__ is Allele, f'Expected parse("C*12:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_35():
    result = parse("C*12:35")
    assert result.__class__ is Allele, f'Expected parse("C*12:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_36():
    result = parse("C*12:36")
    assert result.__class__ is Allele, f'Expected parse("C*12:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_37():
    result = parse("C*12:37")
    assert result.__class__ is Allele, f'Expected parse("C*12:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_38():
    result = parse("C*12:38")
    assert result.__class__ is Allele, f'Expected parse("C*12:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_39N():
    result = parse("C*12:39N")
    assert result.__class__ is Allele, f'Expected parse("C*12:39N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:39N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_40():
    result = parse("C*12:40")
    assert result.__class__ is Allele, f'Expected parse("C*12:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_41():
    result = parse("C*12:41")
    assert result.__class__ is Allele, f'Expected parse("C*12:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_42Q():
    result = parse("C*12:42Q")
    assert result.__class__ is Allele, f'Expected parse("C*12:42Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:42Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_43():
    result = parse("C*12:43")
    assert result.__class__ is Allele, f'Expected parse("C*12:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_44():
    result = parse("C*12:44")
    assert result.__class__ is Allele, f'Expected parse("C*12:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_45():
    result = parse("C*12:45")
    assert result.__class__ is Allele, f'Expected parse("C*12:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_46N():
    result = parse("C*12:46N")
    assert result.__class__ is Allele, f'Expected parse("C*12:46N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:46N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_47():
    result = parse("C*12:47")
    assert result.__class__ is Allele, f'Expected parse("C*12:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_48():
    result = parse("C*12:48")
    assert result.__class__ is Allele, f'Expected parse("C*12:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_49():
    result = parse("C*12:49")
    assert result.__class__ is Allele, f'Expected parse("C*12:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_50():
    result = parse("C*12:50")
    assert result.__class__ is Allele, f'Expected parse("C*12:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_51():
    result = parse("C*12:51")
    assert result.__class__ is Allele, f'Expected parse("C*12:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_52():
    result = parse("C*12:52")
    assert result.__class__ is Allele, f'Expected parse("C*12:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_53():
    result = parse("C*12:53")
    assert result.__class__ is Allele, f'Expected parse("C*12:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_54():
    result = parse("C*12:54")
    assert result.__class__ is Allele, f'Expected parse("C*12:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_55():
    result = parse("C*12:55")
    assert result.__class__ is Allele, f'Expected parse("C*12:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_56():
    result = parse("C*12:56")
    assert result.__class__ is Allele, f'Expected parse("C*12:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_57_01():
    result = parse("C*12:57:01")
    assert result.__class__ is Allele, f'Expected parse("C*12:57:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:57:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_57_02():
    result = parse("C*12:57:02")
    assert result.__class__ is Allele, f'Expected parse("C*12:57:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:57:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_58():
    result = parse("C*12:58")
    assert result.__class__ is Allele, f'Expected parse("C*12:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_59():
    result = parse("C*12:59")
    assert result.__class__ is Allele, f'Expected parse("C*12:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_60():
    result = parse("C*12:60")
    assert result.__class__ is Allele, f'Expected parse("C*12:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_61():
    result = parse("C*12:61")
    assert result.__class__ is Allele, f'Expected parse("C*12:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_62():
    result = parse("C*12:62")
    assert result.__class__ is Allele, f'Expected parse("C*12:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_63():
    result = parse("C*12:63")
    assert result.__class__ is Allele, f'Expected parse("C*12:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_64():
    result = parse("C*12:64")
    assert result.__class__ is Allele, f'Expected parse("C*12:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_65():
    result = parse("C*12:65")
    assert result.__class__ is Allele, f'Expected parse("C*12:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_66():
    result = parse("C*12:66")
    assert result.__class__ is Allele, f'Expected parse("C*12:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_67():
    result = parse("C*12:67")
    assert result.__class__ is Allele, f'Expected parse("C*12:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_68():
    result = parse("C*12:68")
    assert result.__class__ is Allele, f'Expected parse("C*12:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_69():
    result = parse("C*12:69")
    assert result.__class__ is Allele, f'Expected parse("C*12:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_70():
    result = parse("C*12:70")
    assert result.__class__ is Allele, f'Expected parse("C*12:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_71():
    result = parse("C*12:71")
    assert result.__class__ is Allele, f'Expected parse("C*12:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_72():
    result = parse("C*12:72")
    assert result.__class__ is Allele, f'Expected parse("C*12:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_73():
    result = parse("C*12:73")
    assert result.__class__ is Allele, f'Expected parse("C*12:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_74():
    result = parse("C*12:74")
    assert result.__class__ is Allele, f'Expected parse("C*12:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_75():
    result = parse("C*12:75")
    assert result.__class__ is Allele, f'Expected parse("C*12:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_76():
    result = parse("C*12:76")
    assert result.__class__ is Allele, f'Expected parse("C*12:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_77():
    result = parse("C*12:77")
    assert result.__class__ is Allele, f'Expected parse("C*12:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_78():
    result = parse("C*12:78")
    assert result.__class__ is Allele, f'Expected parse("C*12:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_79():
    result = parse("C*12:79")
    assert result.__class__ is Allele, f'Expected parse("C*12:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_80N():
    result = parse("C*12:80N")
    assert result.__class__ is Allele, f'Expected parse("C*12:80N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:80N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_81():
    result = parse("C*12:81")
    assert result.__class__ is Allele, f'Expected parse("C*12:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_82():
    result = parse("C*12:82")
    assert result.__class__ is Allele, f'Expected parse("C*12:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_83():
    result = parse("C*12:83")
    assert result.__class__ is Allele, f'Expected parse("C*12:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_84N():
    result = parse("C*12:84N")
    assert result.__class__ is Allele, f'Expected parse("C*12:84N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:84N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_85():
    result = parse("C*12:85")
    assert result.__class__ is Allele, f'Expected parse("C*12:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_86():
    result = parse("C*12:86")
    assert result.__class__ is Allele, f'Expected parse("C*12:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_87():
    result = parse("C*12:87")
    assert result.__class__ is Allele, f'Expected parse("C*12:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_88():
    result = parse("C*12:88")
    assert result.__class__ is Allele, f'Expected parse("C*12:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_89():
    result = parse("C*12:89")
    assert result.__class__ is Allele, f'Expected parse("C*12:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_90():
    result = parse("C*12:90")
    assert result.__class__ is Allele, f'Expected parse("C*12:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_91():
    result = parse("C*12:91")
    assert result.__class__ is Allele, f'Expected parse("C*12:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_92():
    result = parse("C*12:92")
    assert result.__class__ is Allele, f'Expected parse("C*12:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_93():
    result = parse("C*12:93")
    assert result.__class__ is Allele, f'Expected parse("C*12:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_94():
    result = parse("C*12:94")
    assert result.__class__ is Allele, f'Expected parse("C*12:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_95():
    result = parse("C*12:95")
    assert result.__class__ is Allele, f'Expected parse("C*12:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_96():
    result = parse("C*12:96")
    assert result.__class__ is Allele, f'Expected parse("C*12:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_97():
    result = parse("C*12:97")
    assert result.__class__ is Allele, f'Expected parse("C*12:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_98():
    result = parse("C*12:98")
    assert result.__class__ is Allele, f'Expected parse("C*12:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*12:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_99_01():
    result = parse("C*12:99:01")
    assert result.__class__ is Allele, f'Expected parse("C*12:99:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:99:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_12_99_02():
    result = parse("C*12:99:02")
    assert result.__class__ is Allele, f'Expected parse("C*12:99:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*12:99:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_01():
    result = parse("C*14:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_02():
    result = parse("C*14:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_03():
    result = parse("C*14:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_04():
    result = parse("C*14:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_05():
    result = parse("C*14:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_06():
    result = parse("C*14:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_07():
    result = parse("C*14:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_08():
    result = parse("C*14:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_09():
    result = parse("C*14:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_10():
    result = parse("C*14:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_11():
    result = parse("C*14:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_12():
    result = parse("C*14:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_13():
    result = parse("C*14:02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_14():
    result = parse("C*14:02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_15():
    result = parse("C*14:02:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_16():
    result = parse("C*14:02:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_17():
    result = parse("C*14:02:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_18():
    result = parse("C*14:02:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_01_19():
    result = parse("C*14:02:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:02:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:02:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_02():
    result = parse("C*14:02:02")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_03():
    result = parse("C*14:02:03")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_04():
    result = parse("C*14:02:04")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_05():
    result = parse("C*14:02:05")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_06():
    result = parse("C*14:02:06")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_07():
    result = parse("C*14:02:07")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_08():
    result = parse("C*14:02:08")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_09():
    result = parse("C*14:02:09")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_10():
    result = parse("C*14:02:10")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_11():
    result = parse("C*14:02:11")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_12():
    result = parse("C*14:02:12")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_13():
    result = parse("C*14:02:13")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_14():
    result = parse("C*14:02:14")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_15():
    result = parse("C*14:02:15")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_16():
    result = parse("C*14:02:16")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_17():
    result = parse("C*14:02:17")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_18():
    result = parse("C*14:02:18")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_19():
    result = parse("C*14:02:19")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_20():
    result = parse("C*14:02:20")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_21():
    result = parse("C*14:02:21")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_22():
    result = parse("C*14:02:22")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_23():
    result = parse("C*14:02:23")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_24():
    result = parse("C*14:02:24")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_25():
    result = parse("C*14:02:25")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_26():
    result = parse("C*14:02:26")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_27():
    result = parse("C*14:02:27")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_28():
    result = parse("C*14:02:28")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_29():
    result = parse("C*14:02:29")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_30():
    result = parse("C*14:02:30")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_31():
    result = parse("C*14:02:31")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_32():
    result = parse("C*14:02:32")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_33():
    result = parse("C*14:02:33")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_34():
    result = parse("C*14:02:34")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_35():
    result = parse("C*14:02:35")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_36():
    result = parse("C*14:02:36")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_02_37():
    result = parse("C*14:02:37")
    assert result.__class__ is Allele, f'Expected parse("C*14:02:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:02:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_03_01_01():
    result = parse("C*14:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_03_01_02():
    result = parse("C*14:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*14:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_03_02():
    result = parse("C*14:03:02")
    assert result.__class__ is Allele, f'Expected parse("C*14:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_03_03():
    result = parse("C*14:03:03")
    assert result.__class__ is Allele, f'Expected parse("C*14:03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_03_04():
    result = parse("C*14:03:04")
    assert result.__class__ is Allele, f'Expected parse("C*14:03:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_03_05():
    result = parse("C*14:03:05")
    assert result.__class__ is Allele, f'Expected parse("C*14:03:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_04():
    result = parse("C*14:04")
    assert result.__class__ is Allele, f'Expected parse("C*14:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_05():
    result = parse("C*14:05")
    assert result.__class__ is Allele, f'Expected parse("C*14:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_06():
    result = parse("C*14:06")
    assert result.__class__ is Allele, f'Expected parse("C*14:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_07N():
    result = parse("C*14:07N")
    assert result.__class__ is Allele, f'Expected parse("C*14:07N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:07N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_08():
    result = parse("C*14:08")
    assert result.__class__ is Allele, f'Expected parse("C*14:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_09():
    result = parse("C*14:09")
    assert result.__class__ is Allele, f'Expected parse("C*14:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_10():
    result = parse("C*14:10")
    assert result.__class__ is Allele, f'Expected parse("C*14:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_100():
    result = parse("C*14:100")
    assert result.__class__ is Allele, f'Expected parse("C*14:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_101():
    result = parse("C*14:101")
    assert result.__class__ is Allele, f'Expected parse("C*14:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_102():
    result = parse("C*14:102")
    assert result.__class__ is Allele, f'Expected parse("C*14:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_103():
    result = parse("C*14:103")
    assert result.__class__ is Allele, f'Expected parse("C*14:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_104():
    result = parse("C*14:104")
    assert result.__class__ is Allele, f'Expected parse("C*14:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_105Q():
    result = parse("C*14:105Q")
    assert result.__class__ is Allele, f'Expected parse("C*14:105Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:105Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_106():
    result = parse("C*14:106")
    assert result.__class__ is Allele, f'Expected parse("C*14:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_107():
    result = parse("C*14:107")
    assert result.__class__ is Allele, f'Expected parse("C*14:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_108():
    result = parse("C*14:108")
    assert result.__class__ is Allele, f'Expected parse("C*14:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_109():
    result = parse("C*14:109")
    assert result.__class__ is Allele, f'Expected parse("C*14:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_11():
    result = parse("C*14:11")
    assert result.__class__ is Allele, f'Expected parse("C*14:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_110():
    result = parse("C*14:110")
    assert result.__class__ is Allele, f'Expected parse("C*14:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_111():
    result = parse("C*14:111")
    assert result.__class__ is Allele, f'Expected parse("C*14:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_112():
    result = parse("C*14:112")
    assert result.__class__ is Allele, f'Expected parse("C*14:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_113():
    result = parse("C*14:113")
    assert result.__class__ is Allele, f'Expected parse("C*14:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_114():
    result = parse("C*14:114")
    assert result.__class__ is Allele, f'Expected parse("C*14:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_115():
    result = parse("C*14:115")
    assert result.__class__ is Allele, f'Expected parse("C*14:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_116():
    result = parse("C*14:116")
    assert result.__class__ is Allele, f'Expected parse("C*14:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_117N():
    result = parse("C*14:117N")
    assert result.__class__ is Allele, f'Expected parse("C*14:117N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:117N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_118():
    result = parse("C*14:118")
    assert result.__class__ is Allele, f'Expected parse("C*14:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_119():
    result = parse("C*14:119")
    assert result.__class__ is Allele, f'Expected parse("C*14:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_12():
    result = parse("C*14:12")
    assert result.__class__ is Allele, f'Expected parse("C*14:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_120():
    result = parse("C*14:120")
    assert result.__class__ is Allele, f'Expected parse("C*14:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_13():
    result = parse("C*14:13")
    assert result.__class__ is Allele, f'Expected parse("C*14:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_14():
    result = parse("C*14:14")
    assert result.__class__ is Allele, f'Expected parse("C*14:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_15():
    result = parse("C*14:15")
    assert result.__class__ is Allele, f'Expected parse("C*14:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_16():
    result = parse("C*14:16")
    assert result.__class__ is Allele, f'Expected parse("C*14:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_17():
    result = parse("C*14:17")
    assert result.__class__ is Allele, f'Expected parse("C*14:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_18():
    result = parse("C*14:18")
    assert result.__class__ is Allele, f'Expected parse("C*14:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_19():
    result = parse("C*14:19")
    assert result.__class__ is Allele, f'Expected parse("C*14:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_20():
    result = parse("C*14:20")
    assert result.__class__ is Allele, f'Expected parse("C*14:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_21N():
    result = parse("C*14:21N")
    assert result.__class__ is Allele, f'Expected parse("C*14:21N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:21N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_22():
    result = parse("C*14:22")
    assert result.__class__ is Allele, f'Expected parse("C*14:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_23():
    result = parse("C*14:23")
    assert result.__class__ is Allele, f'Expected parse("C*14:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_24_01():
    result = parse("C*14:24:01")
    assert result.__class__ is Allele, f'Expected parse("C*14:24:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:24:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_24_02():
    result = parse("C*14:24:02")
    assert result.__class__ is Allele, f'Expected parse("C*14:24:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:24:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_25():
    result = parse("C*14:25")
    assert result.__class__ is Allele, f'Expected parse("C*14:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_26():
    result = parse("C*14:26")
    assert result.__class__ is Allele, f'Expected parse("C*14:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_27():
    result = parse("C*14:27")
    assert result.__class__ is Allele, f'Expected parse("C*14:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_28_01():
    result = parse("C*14:28:01")
    assert result.__class__ is Allele, f'Expected parse("C*14:28:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:28:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_28_02():
    result = parse("C*14:28:02")
    assert result.__class__ is Allele, f'Expected parse("C*14:28:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:28:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_29():
    result = parse("C*14:29")
    assert result.__class__ is Allele, f'Expected parse("C*14:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_30():
    result = parse("C*14:30")
    assert result.__class__ is Allele, f'Expected parse("C*14:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_31():
    result = parse("C*14:31")
    assert result.__class__ is Allele, f'Expected parse("C*14:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_32():
    result = parse("C*14:32")
    assert result.__class__ is Allele, f'Expected parse("C*14:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_33():
    result = parse("C*14:33")
    assert result.__class__ is Allele, f'Expected parse("C*14:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_34():
    result = parse("C*14:34")
    assert result.__class__ is Allele, f'Expected parse("C*14:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_35N():
    result = parse("C*14:35N")
    assert result.__class__ is Allele, f'Expected parse("C*14:35N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:35N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_36():
    result = parse("C*14:36")
    assert result.__class__ is Allele, f'Expected parse("C*14:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_37():
    result = parse("C*14:37")
    assert result.__class__ is Allele, f'Expected parse("C*14:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_38():
    result = parse("C*14:38")
    assert result.__class__ is Allele, f'Expected parse("C*14:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_39():
    result = parse("C*14:39")
    assert result.__class__ is Allele, f'Expected parse("C*14:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_40():
    result = parse("C*14:40")
    assert result.__class__ is Allele, f'Expected parse("C*14:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_41():
    result = parse("C*14:41")
    assert result.__class__ is Allele, f'Expected parse("C*14:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_42():
    result = parse("C*14:42")
    assert result.__class__ is Allele, f'Expected parse("C*14:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_43():
    result = parse("C*14:43")
    assert result.__class__ is Allele, f'Expected parse("C*14:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_44():
    result = parse("C*14:44")
    assert result.__class__ is Allele, f'Expected parse("C*14:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_45():
    result = parse("C*14:45")
    assert result.__class__ is Allele, f'Expected parse("C*14:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_46_01():
    result = parse("C*14:46:01")
    assert result.__class__ is Allele, f'Expected parse("C*14:46:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:46:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_46_02():
    result = parse("C*14:46:02")
    assert result.__class__ is Allele, f'Expected parse("C*14:46:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:46:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_47_01N():
    result = parse("C*14:47:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:47:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:47:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_47_02N():
    result = parse("C*14:47:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*14:47:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*14:47:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_48():
    result = parse("C*14:48")
    assert result.__class__ is Allele, f'Expected parse("C*14:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_49():
    result = parse("C*14:49")
    assert result.__class__ is Allele, f'Expected parse("C*14:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_50():
    result = parse("C*14:50")
    assert result.__class__ is Allele, f'Expected parse("C*14:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_51():
    result = parse("C*14:51")
    assert result.__class__ is Allele, f'Expected parse("C*14:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_52():
    result = parse("C*14:52")
    assert result.__class__ is Allele, f'Expected parse("C*14:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_53():
    result = parse("C*14:53")
    assert result.__class__ is Allele, f'Expected parse("C*14:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_54():
    result = parse("C*14:54")
    assert result.__class__ is Allele, f'Expected parse("C*14:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_55():
    result = parse("C*14:55")
    assert result.__class__ is Allele, f'Expected parse("C*14:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_56():
    result = parse("C*14:56")
    assert result.__class__ is Allele, f'Expected parse("C*14:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_57():
    result = parse("C*14:57")
    assert result.__class__ is Allele, f'Expected parse("C*14:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_58():
    result = parse("C*14:58")
    assert result.__class__ is Allele, f'Expected parse("C*14:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_59():
    result = parse("C*14:59")
    assert result.__class__ is Allele, f'Expected parse("C*14:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_60():
    result = parse("C*14:60")
    assert result.__class__ is Allele, f'Expected parse("C*14:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_61():
    result = parse("C*14:61")
    assert result.__class__ is Allele, f'Expected parse("C*14:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_62():
    result = parse("C*14:62")
    assert result.__class__ is Allele, f'Expected parse("C*14:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_63():
    result = parse("C*14:63")
    assert result.__class__ is Allele, f'Expected parse("C*14:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_64():
    result = parse("C*14:64")
    assert result.__class__ is Allele, f'Expected parse("C*14:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_65():
    result = parse("C*14:65")
    assert result.__class__ is Allele, f'Expected parse("C*14:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_66():
    result = parse("C*14:66")
    assert result.__class__ is Allele, f'Expected parse("C*14:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_67():
    result = parse("C*14:67")
    assert result.__class__ is Allele, f'Expected parse("C*14:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_68():
    result = parse("C*14:68")
    assert result.__class__ is Allele, f'Expected parse("C*14:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_69():
    result = parse("C*14:69")
    assert result.__class__ is Allele, f'Expected parse("C*14:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_70():
    result = parse("C*14:70")
    assert result.__class__ is Allele, f'Expected parse("C*14:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_71():
    result = parse("C*14:71")
    assert result.__class__ is Allele, f'Expected parse("C*14:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_72():
    result = parse("C*14:72")
    assert result.__class__ is Allele, f'Expected parse("C*14:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_73():
    result = parse("C*14:73")
    assert result.__class__ is Allele, f'Expected parse("C*14:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_74():
    result = parse("C*14:74")
    assert result.__class__ is Allele, f'Expected parse("C*14:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_75():
    result = parse("C*14:75")
    assert result.__class__ is Allele, f'Expected parse("C*14:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_76():
    result = parse("C*14:76")
    assert result.__class__ is Allele, f'Expected parse("C*14:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_77():
    result = parse("C*14:77")
    assert result.__class__ is Allele, f'Expected parse("C*14:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_78():
    result = parse("C*14:78")
    assert result.__class__ is Allele, f'Expected parse("C*14:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_79():
    result = parse("C*14:79")
    assert result.__class__ is Allele, f'Expected parse("C*14:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_80():
    result = parse("C*14:80")
    assert result.__class__ is Allele, f'Expected parse("C*14:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_81():
    result = parse("C*14:81")
    assert result.__class__ is Allele, f'Expected parse("C*14:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_82():
    result = parse("C*14:82")
    assert result.__class__ is Allele, f'Expected parse("C*14:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_83():
    result = parse("C*14:83")
    assert result.__class__ is Allele, f'Expected parse("C*14:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_84():
    result = parse("C*14:84")
    assert result.__class__ is Allele, f'Expected parse("C*14:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_85():
    result = parse("C*14:85")
    assert result.__class__ is Allele, f'Expected parse("C*14:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_86():
    result = parse("C*14:86")
    assert result.__class__ is Allele, f'Expected parse("C*14:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_87():
    result = parse("C*14:87")
    assert result.__class__ is Allele, f'Expected parse("C*14:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_88():
    result = parse("C*14:88")
    assert result.__class__ is Allele, f'Expected parse("C*14:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_89():
    result = parse("C*14:89")
    assert result.__class__ is Allele, f'Expected parse("C*14:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_90():
    result = parse("C*14:90")
    assert result.__class__ is Allele, f'Expected parse("C*14:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_91():
    result = parse("C*14:91")
    assert result.__class__ is Allele, f'Expected parse("C*14:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_92():
    result = parse("C*14:92")
    assert result.__class__ is Allele, f'Expected parse("C*14:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_93N():
    result = parse("C*14:93N")
    assert result.__class__ is Allele, f'Expected parse("C*14:93N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:93N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_94():
    result = parse("C*14:94")
    assert result.__class__ is Allele, f'Expected parse("C*14:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_95():
    result = parse("C*14:95")
    assert result.__class__ is Allele, f'Expected parse("C*14:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_96():
    result = parse("C*14:96")
    assert result.__class__ is Allele, f'Expected parse("C*14:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_97N():
    result = parse("C*14:97N")
    assert result.__class__ is Allele, f'Expected parse("C*14:97N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:97N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_98():
    result = parse("C*14:98")
    assert result.__class__ is Allele, f'Expected parse("C*14:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_14_99N():
    result = parse("C*14:99N")
    assert result.__class__ is Allele, f'Expected parse("C*14:99N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*14:99N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_01():
    result = parse("C*15:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_02():
    result = parse("C*15:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_03():
    result = parse("C*15:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_04():
    result = parse("C*15:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_05():
    result = parse("C*15:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_06():
    result = parse("C*15:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_07():
    result = parse("C*15:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_08N():
    result = parse("C*15:02:01:08N")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:08N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:08N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_09():
    result = parse("C*15:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_10():
    result = parse("C*15:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_11():
    result = parse("C*15:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_12():
    result = parse("C*15:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_13():
    result = parse("C*15:02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_14():
    result = parse("C*15:02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_15():
    result = parse("C*15:02:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_16():
    result = parse("C*15:02:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_17():
    result = parse("C*15:02:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_18():
    result = parse("C*15:02:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_19():
    result = parse("C*15:02:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_20():
    result = parse("C*15:02:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_21():
    result = parse("C*15:02:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_22():
    result = parse("C*15:02:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_23():
    result = parse("C*15:02:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_24():
    result = parse("C*15:02:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_25():
    result = parse("C*15:02:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_26():
    result = parse("C*15:02:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_27():
    result = parse("C*15:02:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_28():
    result = parse("C*15:02:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_01_29():
    result = parse("C*15:02:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_02_01():
    result = parse("C*15:02:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_02_02():
    result = parse("C*15:02:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_03():
    result = parse("C*15:02:03")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_04():
    result = parse("C*15:02:04")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_05():
    result = parse("C*15:02:05")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_06():
    result = parse("C*15:02:06")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_07():
    result = parse("C*15:02:07")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_08():
    result = parse("C*15:02:08")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_09():
    result = parse("C*15:02:09")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_10():
    result = parse("C*15:02:10")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_11():
    result = parse("C*15:02:11")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_12():
    result = parse("C*15:02:12")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_13():
    result = parse("C*15:02:13")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_14():
    result = parse("C*15:02:14")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_15():
    result = parse("C*15:02:15")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_16():
    result = parse("C*15:02:16")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_17():
    result = parse("C*15:02:17")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_18():
    result = parse("C*15:02:18")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_19():
    result = parse("C*15:02:19")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_20():
    result = parse("C*15:02:20")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_21():
    result = parse("C*15:02:21")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_22():
    result = parse("C*15:02:22")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_23():
    result = parse("C*15:02:23")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_24():
    result = parse("C*15:02:24")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_25():
    result = parse("C*15:02:25")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_26():
    result = parse("C*15:02:26")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_27():
    result = parse("C*15:02:27")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_28():
    result = parse("C*15:02:28")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_29():
    result = parse("C*15:02:29")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_30():
    result = parse("C*15:02:30")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_31():
    result = parse("C*15:02:31")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_32():
    result = parse("C*15:02:32")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_33_01():
    result = parse("C*15:02:33:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:33:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:33:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_33_02():
    result = parse("C*15:02:33:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:02:33:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:02:33:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_34():
    result = parse("C*15:02:34")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_35():
    result = parse("C*15:02:35")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_36():
    result = parse("C*15:02:36")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_37():
    result = parse("C*15:02:37")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_38():
    result = parse("C*15:02:38")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_39():
    result = parse("C*15:02:39")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_40():
    result = parse("C*15:02:40")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:40") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_41():
    result = parse("C*15:02:41")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:41") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_42():
    result = parse("C*15:02:42")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:42") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_43():
    result = parse("C*15:02:43")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:43") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_44():
    result = parse("C*15:02:44")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:44") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_02_45():
    result = parse("C*15:02:45")
    assert result.__class__ is Allele, f'Expected parse("C*15:02:45") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:02:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_03():
    result = parse("C*15:03")
    assert result.__class__ is Allele, f'Expected parse("C*15:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_04_01_01():
    result = parse("C*15:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_04_01_02():
    result = parse("C*15:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_04_01_03():
    result = parse("C*15:04:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:04:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:04:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_04_02():
    result = parse("C*15:04:02")
    assert result.__class__ is Allele, f'Expected parse("C*15:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_04_03():
    result = parse("C*15:04:03")
    assert result.__class__ is Allele, f'Expected parse("C*15:04:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_01_01():
    result = parse("C*15:05:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:05:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:05:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_01_02():
    result = parse("C*15:05:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:05:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:05:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_01_03():
    result = parse("C*15:05:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:05:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:05:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_02_01():
    result = parse("C*15:05:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:05:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:05:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_02_02():
    result = parse("C*15:05:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:05:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:05:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_02_03():
    result = parse("C*15:05:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:05:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:05:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_02_04():
    result = parse("C*15:05:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:05:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:05:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_02_05():
    result = parse("C*15:05:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:05:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:05:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_02_06():
    result = parse("C*15:05:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:05:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:05:02:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_02_07():
    result = parse("C*15:05:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:05:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:05:02:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_02_08():
    result = parse("C*15:05:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:05:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:05:02:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_03():
    result = parse("C*15:05:03")
    assert result.__class__ is Allele, f'Expected parse("C*15:05:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:05:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_04():
    result = parse("C*15:05:04")
    assert result.__class__ is Allele, f'Expected parse("C*15:05:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:05:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_05():
    result = parse("C*15:05:05")
    assert result.__class__ is Allele, f'Expected parse("C*15:05:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:05:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_06():
    result = parse("C*15:05:06")
    assert result.__class__ is Allele, f'Expected parse("C*15:05:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:05:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_07():
    result = parse("C*15:05:07")
    assert result.__class__ is Allele, f'Expected parse("C*15:05:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:05:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_09():
    result = parse("C*15:05:09")
    assert result.__class__ is Allele, f'Expected parse("C*15:05:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:05:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_10():
    result = parse("C*15:05:10")
    assert result.__class__ is Allele, f'Expected parse("C*15:05:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:05:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_11():
    result = parse("C*15:05:11")
    assert result.__class__ is Allele, f'Expected parse("C*15:05:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:05:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_12():
    result = parse("C*15:05:12")
    assert result.__class__ is Allele, f'Expected parse("C*15:05:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:05:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_13():
    result = parse("C*15:05:13")
    assert result.__class__ is Allele, f'Expected parse("C*15:05:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:05:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_14():
    result = parse("C*15:05:14")
    assert result.__class__ is Allele, f'Expected parse("C*15:05:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:05:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_15():
    result = parse("C*15:05:15")
    assert result.__class__ is Allele, f'Expected parse("C*15:05:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:05:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_05_16():
    result = parse("C*15:05:16")
    assert result.__class__ is Allele, f'Expected parse("C*15:05:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:05:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_06_01():
    result = parse("C*15:06:01")
    assert result.__class__ is Allele, f'Expected parse("C*15:06:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_06_02():
    result = parse("C*15:06:02")
    assert result.__class__ is Allele, f'Expected parse("C*15:06:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_06_03():
    result = parse("C*15:06:03")
    assert result.__class__ is Allele, f'Expected parse("C*15:06:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:06:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_07_01_01():
    result = parse("C*15:07:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:07:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:07:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_07_01_02():
    result = parse("C*15:07:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:07:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:07:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_08_01():
    result = parse("C*15:08:01")
    assert result.__class__ is Allele, f'Expected parse("C*15:08:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:08:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_08_02():
    result = parse("C*15:08:02")
    assert result.__class__ is Allele, f'Expected parse("C*15:08:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:08:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_09_01_01():
    result = parse("C*15:09:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:09:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:09:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_09_01_02():
    result = parse("C*15:09:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:09:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:09:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_09_02():
    result = parse("C*15:09:02")
    assert result.__class__ is Allele, f'Expected parse("C*15:09:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:09:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_100():
    result = parse("C*15:100")
    assert result.__class__ is Allele, f'Expected parse("C*15:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_101():
    result = parse("C*15:101")
    assert result.__class__ is Allele, f'Expected parse("C*15:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_102():
    result = parse("C*15:102")
    assert result.__class__ is Allele, f'Expected parse("C*15:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_103():
    result = parse("C*15:103")
    assert result.__class__ is Allele, f'Expected parse("C*15:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_104():
    result = parse("C*15:104")
    assert result.__class__ is Allele, f'Expected parse("C*15:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_105Q():
    result = parse("C*15:105Q")
    assert result.__class__ is Allele, f'Expected parse("C*15:105Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:105Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_106():
    result = parse("C*15:106")
    assert result.__class__ is Allele, f'Expected parse("C*15:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_107():
    result = parse("C*15:107")
    assert result.__class__ is Allele, f'Expected parse("C*15:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_108():
    result = parse("C*15:108")
    assert result.__class__ is Allele, f'Expected parse("C*15:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_109():
    result = parse("C*15:109")
    assert result.__class__ is Allele, f'Expected parse("C*15:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_10_01():
    result = parse("C*15:10:01")
    assert result.__class__ is Allele, f'Expected parse("C*15:10:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:10:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_10_02():
    result = parse("C*15:10:02")
    assert result.__class__ is Allele, f'Expected parse("C*15:10:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:10:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_10_03():
    result = parse("C*15:10:03")
    assert result.__class__ is Allele, f'Expected parse("C*15:10:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:10:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_10_04():
    result = parse("C*15:10:04")
    assert result.__class__ is Allele, f'Expected parse("C*15:10:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:10:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_11():
    result = parse("C*15:11")
    assert result.__class__ is Allele, f'Expected parse("C*15:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_110():
    result = parse("C*15:110")
    assert result.__class__ is Allele, f'Expected parse("C*15:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_111():
    result = parse("C*15:111")
    assert result.__class__ is Allele, f'Expected parse("C*15:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_112():
    result = parse("C*15:112")
    assert result.__class__ is Allele, f'Expected parse("C*15:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_113():
    result = parse("C*15:113")
    assert result.__class__ is Allele, f'Expected parse("C*15:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_114():
    result = parse("C*15:114")
    assert result.__class__ is Allele, f'Expected parse("C*15:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_115N():
    result = parse("C*15:115N")
    assert result.__class__ is Allele, f'Expected parse("C*15:115N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:115N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_116():
    result = parse("C*15:116")
    assert result.__class__ is Allele, f'Expected parse("C*15:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_117():
    result = parse("C*15:117")
    assert result.__class__ is Allele, f'Expected parse("C*15:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_118():
    result = parse("C*15:118")
    assert result.__class__ is Allele, f'Expected parse("C*15:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_119():
    result = parse("C*15:119")
    assert result.__class__ is Allele, f'Expected parse("C*15:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_12():
    result = parse("C*15:12")
    assert result.__class__ is Allele, f'Expected parse("C*15:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_120():
    result = parse("C*15:120")
    assert result.__class__ is Allele, f'Expected parse("C*15:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_121():
    result = parse("C*15:121")
    assert result.__class__ is Allele, f'Expected parse("C*15:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_122N():
    result = parse("C*15:122N")
    assert result.__class__ is Allele, f'Expected parse("C*15:122N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:122N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_123():
    result = parse("C*15:123")
    assert result.__class__ is Allele, f'Expected parse("C*15:123") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_124():
    result = parse("C*15:124")
    assert result.__class__ is Allele, f'Expected parse("C*15:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_125():
    result = parse("C*15:125")
    assert result.__class__ is Allele, f'Expected parse("C*15:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_126():
    result = parse("C*15:126")
    assert result.__class__ is Allele, f'Expected parse("C*15:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_127():
    result = parse("C*15:127")
    assert result.__class__ is Allele, f'Expected parse("C*15:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_128():
    result = parse("C*15:128")
    assert result.__class__ is Allele, f'Expected parse("C*15:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_129():
    result = parse("C*15:129")
    assert result.__class__ is Allele, f'Expected parse("C*15:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_130():
    result = parse("C*15:130")
    assert result.__class__ is Allele, f'Expected parse("C*15:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_131():
    result = parse("C*15:131")
    assert result.__class__ is Allele, f'Expected parse("C*15:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_132():
    result = parse("C*15:132")
    assert result.__class__ is Allele, f'Expected parse("C*15:132") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_133():
    result = parse("C*15:133")
    assert result.__class__ is Allele, f'Expected parse("C*15:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_134():
    result = parse("C*15:134")
    assert result.__class__ is Allele, f'Expected parse("C*15:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_135():
    result = parse("C*15:135")
    assert result.__class__ is Allele, f'Expected parse("C*15:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_136():
    result = parse("C*15:136")
    assert result.__class__ is Allele, f'Expected parse("C*15:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_137():
    result = parse("C*15:137")
    assert result.__class__ is Allele, f'Expected parse("C*15:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_138():
    result = parse("C*15:138")
    assert result.__class__ is Allele, f'Expected parse("C*15:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_139():
    result = parse("C*15:139")
    assert result.__class__ is Allele, f'Expected parse("C*15:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_13_01_01():
    result = parse("C*15:13:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:13:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:13:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_13_01_02():
    result = parse("C*15:13:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:13:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*15:13:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_140():
    result = parse("C*15:140")
    assert result.__class__ is Allele, f'Expected parse("C*15:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_141():
    result = parse("C*15:141")
    assert result.__class__ is Allele, f'Expected parse("C*15:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_142():
    result = parse("C*15:142")
    assert result.__class__ is Allele, f'Expected parse("C*15:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_143():
    result = parse("C*15:143")
    assert result.__class__ is Allele, f'Expected parse("C*15:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_144():
    result = parse("C*15:144")
    assert result.__class__ is Allele, f'Expected parse("C*15:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_145N():
    result = parse("C*15:145N")
    assert result.__class__ is Allele, f'Expected parse("C*15:145N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:145N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_146():
    result = parse("C*15:146")
    assert result.__class__ is Allele, f'Expected parse("C*15:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_147():
    result = parse("C*15:147")
    assert result.__class__ is Allele, f'Expected parse("C*15:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_148():
    result = parse("C*15:148")
    assert result.__class__ is Allele, f'Expected parse("C*15:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_149():
    result = parse("C*15:149")
    assert result.__class__ is Allele, f'Expected parse("C*15:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_15():
    result = parse("C*15:15")
    assert result.__class__ is Allele, f'Expected parse("C*15:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_150():
    result = parse("C*15:150")
    assert result.__class__ is Allele, f'Expected parse("C*15:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_151():
    result = parse("C*15:151")
    assert result.__class__ is Allele, f'Expected parse("C*15:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_152_01():
    result = parse("C*15:152:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:152:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:152:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_152_02():
    result = parse("C*15:152:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:152:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:152:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_152_03():
    result = parse("C*15:152:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*15:152:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:152:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_153():
    result = parse("C*15:153")
    assert result.__class__ is Allele, f'Expected parse("C*15:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_154():
    result = parse("C*15:154")
    assert result.__class__ is Allele, f'Expected parse("C*15:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_155():
    result = parse("C*15:155")
    assert result.__class__ is Allele, f'Expected parse("C*15:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_156N():
    result = parse("C*15:156N")
    assert result.__class__ is Allele, f'Expected parse("C*15:156N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:156N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_157():
    result = parse("C*15:157")
    assert result.__class__ is Allele, f'Expected parse("C*15:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_158():
    result = parse("C*15:158")
    assert result.__class__ is Allele, f'Expected parse("C*15:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_159():
    result = parse("C*15:159")
    assert result.__class__ is Allele, f'Expected parse("C*15:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_16():
    result = parse("C*15:16")
    assert result.__class__ is Allele, f'Expected parse("C*15:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_160N():
    result = parse("C*15:160N")
    assert result.__class__ is Allele, f'Expected parse("C*15:160N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:160N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_161():
    result = parse("C*15:161")
    assert result.__class__ is Allele, f'Expected parse("C*15:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_162():
    result = parse("C*15:162")
    assert result.__class__ is Allele, f'Expected parse("C*15:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_163():
    result = parse("C*15:163")
    assert result.__class__ is Allele, f'Expected parse("C*15:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_164N():
    result = parse("C*15:164N")
    assert result.__class__ is Allele, f'Expected parse("C*15:164N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:164N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_165():
    result = parse("C*15:165")
    assert result.__class__ is Allele, f'Expected parse("C*15:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_166():
    result = parse("C*15:166")
    assert result.__class__ is Allele, f'Expected parse("C*15:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_167():
    result = parse("C*15:167")
    assert result.__class__ is Allele, f'Expected parse("C*15:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_168():
    result = parse("C*15:168")
    assert result.__class__ is Allele, f'Expected parse("C*15:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_169():
    result = parse("C*15:169")
    assert result.__class__ is Allele, f'Expected parse("C*15:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_17():
    result = parse("C*15:17")
    assert result.__class__ is Allele, f'Expected parse("C*15:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_170():
    result = parse("C*15:170")
    assert result.__class__ is Allele, f'Expected parse("C*15:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_171():
    result = parse("C*15:171")
    assert result.__class__ is Allele, f'Expected parse("C*15:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_172():
    result = parse("C*15:172")
    assert result.__class__ is Allele, f'Expected parse("C*15:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_173():
    result = parse("C*15:173")
    assert result.__class__ is Allele, f'Expected parse("C*15:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_174():
    result = parse("C*15:174")
    assert result.__class__ is Allele, f'Expected parse("C*15:174") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_175():
    result = parse("C*15:175")
    assert result.__class__ is Allele, f'Expected parse("C*15:175") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_176():
    result = parse("C*15:176")
    assert result.__class__ is Allele, f'Expected parse("C*15:176") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_177N():
    result = parse("C*15:177N")
    assert result.__class__ is Allele, f'Expected parse("C*15:177N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:177N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_178():
    result = parse("C*15:178")
    assert result.__class__ is Allele, f'Expected parse("C*15:178") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_179():
    result = parse("C*15:179")
    assert result.__class__ is Allele, f'Expected parse("C*15:179") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_18():
    result = parse("C*15:18")
    assert result.__class__ is Allele, f'Expected parse("C*15:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_180():
    result = parse("C*15:180")
    assert result.__class__ is Allele, f'Expected parse("C*15:180") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_181():
    result = parse("C*15:181")
    assert result.__class__ is Allele, f'Expected parse("C*15:181") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_182():
    result = parse("C*15:182")
    assert result.__class__ is Allele, f'Expected parse("C*15:182") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_183():
    result = parse("C*15:183")
    assert result.__class__ is Allele, f'Expected parse("C*15:183") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_184():
    result = parse("C*15:184")
    assert result.__class__ is Allele, f'Expected parse("C*15:184") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_185N():
    result = parse("C*15:185N")
    assert result.__class__ is Allele, f'Expected parse("C*15:185N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:185N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_186():
    result = parse("C*15:186")
    assert result.__class__ is Allele, f'Expected parse("C*15:186") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_187():
    result = parse("C*15:187")
    assert result.__class__ is Allele, f'Expected parse("C*15:187") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_188N():
    result = parse("C*15:188N")
    assert result.__class__ is Allele, f'Expected parse("C*15:188N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:188N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_189N():
    result = parse("C*15:189N")
    assert result.__class__ is Allele, f'Expected parse("C*15:189N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:189N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_19():
    result = parse("C*15:19")
    assert result.__class__ is Allele, f'Expected parse("C*15:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_190():
    result = parse("C*15:190")
    assert result.__class__ is Allele, f'Expected parse("C*15:190") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_191():
    result = parse("C*15:191")
    assert result.__class__ is Allele, f'Expected parse("C*15:191") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_192():
    result = parse("C*15:192")
    assert result.__class__ is Allele, f'Expected parse("C*15:192") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_193():
    result = parse("C*15:193")
    assert result.__class__ is Allele, f'Expected parse("C*15:193") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_194():
    result = parse("C*15:194")
    assert result.__class__ is Allele, f'Expected parse("C*15:194") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_195():
    result = parse("C*15:195")
    assert result.__class__ is Allele, f'Expected parse("C*15:195") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_196():
    result = parse("C*15:196")
    assert result.__class__ is Allele, f'Expected parse("C*15:196") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_197():
    result = parse("C*15:197")
    assert result.__class__ is Allele, f'Expected parse("C*15:197") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_198():
    result = parse("C*15:198")
    assert result.__class__ is Allele, f'Expected parse("C*15:198") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_199():
    result = parse("C*15:199")
    assert result.__class__ is Allele, f'Expected parse("C*15:199") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_200():
    result = parse("C*15:200")
    assert result.__class__ is Allele, f'Expected parse("C*15:200") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_201():
    result = parse("C*15:201")
    assert result.__class__ is Allele, f'Expected parse("C*15:201") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_202():
    result = parse("C*15:202")
    assert result.__class__ is Allele, f'Expected parse("C*15:202") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_203():
    result = parse("C*15:203")
    assert result.__class__ is Allele, f'Expected parse("C*15:203") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_204():
    result = parse("C*15:204")
    assert result.__class__ is Allele, f'Expected parse("C*15:204") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_205():
    result = parse("C*15:205")
    assert result.__class__ is Allele, f'Expected parse("C*15:205") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_206():
    result = parse("C*15:206")
    assert result.__class__ is Allele, f'Expected parse("C*15:206") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_207():
    result = parse("C*15:207")
    assert result.__class__ is Allele, f'Expected parse("C*15:207") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_208():
    result = parse("C*15:208")
    assert result.__class__ is Allele, f'Expected parse("C*15:208") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_209():
    result = parse("C*15:209")
    assert result.__class__ is Allele, f'Expected parse("C*15:209") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_21():
    result = parse("C*15:21")
    assert result.__class__ is Allele, f'Expected parse("C*15:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_210():
    result = parse("C*15:210")
    assert result.__class__ is Allele, f'Expected parse("C*15:210") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_211():
    result = parse("C*15:211")
    assert result.__class__ is Allele, f'Expected parse("C*15:211") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_212():
    result = parse("C*15:212")
    assert result.__class__ is Allele, f'Expected parse("C*15:212") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_213N():
    result = parse("C*15:213N")
    assert result.__class__ is Allele, f'Expected parse("C*15:213N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:213N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_214():
    result = parse("C*15:214")
    assert result.__class__ is Allele, f'Expected parse("C*15:214") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_215():
    result = parse("C*15:215")
    assert result.__class__ is Allele, f'Expected parse("C*15:215") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_216N():
    result = parse("C*15:216N")
    assert result.__class__ is Allele, f'Expected parse("C*15:216N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:216N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_217():
    result = parse("C*15:217")
    assert result.__class__ is Allele, f'Expected parse("C*15:217") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_218():
    result = parse("C*15:218")
    assert result.__class__ is Allele, f'Expected parse("C*15:218") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_219():
    result = parse("C*15:219")
    assert result.__class__ is Allele, f'Expected parse("C*15:219") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_22():
    result = parse("C*15:22")
    assert result.__class__ is Allele, f'Expected parse("C*15:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_220():
    result = parse("C*15:220")
    assert result.__class__ is Allele, f'Expected parse("C*15:220") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_221():
    result = parse("C*15:221")
    assert result.__class__ is Allele, f'Expected parse("C*15:221") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_23_01():
    result = parse("C*15:23:01")
    assert result.__class__ is Allele, f'Expected parse("C*15:23:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:23:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_23_02():
    result = parse("C*15:23:02")
    assert result.__class__ is Allele, f'Expected parse("C*15:23:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:23:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_24():
    result = parse("C*15:24")
    assert result.__class__ is Allele, f'Expected parse("C*15:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_25():
    result = parse("C*15:25")
    assert result.__class__ is Allele, f'Expected parse("C*15:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_26():
    result = parse("C*15:26")
    assert result.__class__ is Allele, f'Expected parse("C*15:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_27():
    result = parse("C*15:27")
    assert result.__class__ is Allele, f'Expected parse("C*15:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_28():
    result = parse("C*15:28")
    assert result.__class__ is Allele, f'Expected parse("C*15:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_29():
    result = parse("C*15:29")
    assert result.__class__ is Allele, f'Expected parse("C*15:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_30():
    result = parse("C*15:30")
    assert result.__class__ is Allele, f'Expected parse("C*15:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_31():
    result = parse("C*15:31")
    assert result.__class__ is Allele, f'Expected parse("C*15:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_32Q():
    result = parse("C*15:32Q")
    assert result.__class__ is Allele, f'Expected parse("C*15:32Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:32Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_33():
    result = parse("C*15:33")
    assert result.__class__ is Allele, f'Expected parse("C*15:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_34():
    result = parse("C*15:34")
    assert result.__class__ is Allele, f'Expected parse("C*15:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_35():
    result = parse("C*15:35")
    assert result.__class__ is Allele, f'Expected parse("C*15:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_36():
    result = parse("C*15:36")
    assert result.__class__ is Allele, f'Expected parse("C*15:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_37():
    result = parse("C*15:37")
    assert result.__class__ is Allele, f'Expected parse("C*15:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_38():
    result = parse("C*15:38")
    assert result.__class__ is Allele, f'Expected parse("C*15:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_39():
    result = parse("C*15:39")
    assert result.__class__ is Allele, f'Expected parse("C*15:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_40():
    result = parse("C*15:40")
    assert result.__class__ is Allele, f'Expected parse("C*15:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_41():
    result = parse("C*15:41")
    assert result.__class__ is Allele, f'Expected parse("C*15:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_42():
    result = parse("C*15:42")
    assert result.__class__ is Allele, f'Expected parse("C*15:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_43():
    result = parse("C*15:43")
    assert result.__class__ is Allele, f'Expected parse("C*15:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_44_01():
    result = parse("C*15:44:01")
    assert result.__class__ is Allele, f'Expected parse("C*15:44:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:44:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_44_02():
    result = parse("C*15:44:02")
    assert result.__class__ is Allele, f'Expected parse("C*15:44:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:44:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_45():
    result = parse("C*15:45")
    assert result.__class__ is Allele, f'Expected parse("C*15:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_46():
    result = parse("C*15:46")
    assert result.__class__ is Allele, f'Expected parse("C*15:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_47():
    result = parse("C*15:47")
    assert result.__class__ is Allele, f'Expected parse("C*15:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_48():
    result = parse("C*15:48")
    assert result.__class__ is Allele, f'Expected parse("C*15:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_49():
    result = parse("C*15:49")
    assert result.__class__ is Allele, f'Expected parse("C*15:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_50():
    result = parse("C*15:50")
    assert result.__class__ is Allele, f'Expected parse("C*15:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_51():
    result = parse("C*15:51")
    assert result.__class__ is Allele, f'Expected parse("C*15:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_52_01():
    result = parse("C*15:52:01")
    assert result.__class__ is Allele, f'Expected parse("C*15:52:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:52:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_52_02():
    result = parse("C*15:52:02")
    assert result.__class__ is Allele, f'Expected parse("C*15:52:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:52:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_53():
    result = parse("C*15:53")
    assert result.__class__ is Allele, f'Expected parse("C*15:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_54():
    result = parse("C*15:54")
    assert result.__class__ is Allele, f'Expected parse("C*15:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_55():
    result = parse("C*15:55")
    assert result.__class__ is Allele, f'Expected parse("C*15:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_56():
    result = parse("C*15:56")
    assert result.__class__ is Allele, f'Expected parse("C*15:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_57():
    result = parse("C*15:57")
    assert result.__class__ is Allele, f'Expected parse("C*15:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_58():
    result = parse("C*15:58")
    assert result.__class__ is Allele, f'Expected parse("C*15:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_59():
    result = parse("C*15:59")
    assert result.__class__ is Allele, f'Expected parse("C*15:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_60():
    result = parse("C*15:60")
    assert result.__class__ is Allele, f'Expected parse("C*15:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_61():
    result = parse("C*15:61")
    assert result.__class__ is Allele, f'Expected parse("C*15:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_62():
    result = parse("C*15:62")
    assert result.__class__ is Allele, f'Expected parse("C*15:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_63():
    result = parse("C*15:63")
    assert result.__class__ is Allele, f'Expected parse("C*15:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_64():
    result = parse("C*15:64")
    assert result.__class__ is Allele, f'Expected parse("C*15:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_65():
    result = parse("C*15:65")
    assert result.__class__ is Allele, f'Expected parse("C*15:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_66():
    result = parse("C*15:66")
    assert result.__class__ is Allele, f'Expected parse("C*15:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_67():
    result = parse("C*15:67")
    assert result.__class__ is Allele, f'Expected parse("C*15:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_68():
    result = parse("C*15:68")
    assert result.__class__ is Allele, f'Expected parse("C*15:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_69():
    result = parse("C*15:69")
    assert result.__class__ is Allele, f'Expected parse("C*15:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_70():
    result = parse("C*15:70")
    assert result.__class__ is Allele, f'Expected parse("C*15:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_71():
    result = parse("C*15:71")
    assert result.__class__ is Allele, f'Expected parse("C*15:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_72():
    result = parse("C*15:72")
    assert result.__class__ is Allele, f'Expected parse("C*15:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_73():
    result = parse("C*15:73")
    assert result.__class__ is Allele, f'Expected parse("C*15:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_74():
    result = parse("C*15:74")
    assert result.__class__ is Allele, f'Expected parse("C*15:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_75():
    result = parse("C*15:75")
    assert result.__class__ is Allele, f'Expected parse("C*15:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_76():
    result = parse("C*15:76")
    assert result.__class__ is Allele, f'Expected parse("C*15:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_77():
    result = parse("C*15:77")
    assert result.__class__ is Allele, f'Expected parse("C*15:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_78_01():
    result = parse("C*15:78:01")
    assert result.__class__ is Allele, f'Expected parse("C*15:78:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:78:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_78_02():
    result = parse("C*15:78:02")
    assert result.__class__ is Allele, f'Expected parse("C*15:78:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*15:78:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_79():
    result = parse("C*15:79")
    assert result.__class__ is Allele, f'Expected parse("C*15:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_80():
    result = parse("C*15:80")
    assert result.__class__ is Allele, f'Expected parse("C*15:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_81():
    result = parse("C*15:81")
    assert result.__class__ is Allele, f'Expected parse("C*15:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_82():
    result = parse("C*15:82")
    assert result.__class__ is Allele, f'Expected parse("C*15:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_83():
    result = parse("C*15:83")
    assert result.__class__ is Allele, f'Expected parse("C*15:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_84Q():
    result = parse("C*15:84Q")
    assert result.__class__ is Allele, f'Expected parse("C*15:84Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:84Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_85():
    result = parse("C*15:85")
    assert result.__class__ is Allele, f'Expected parse("C*15:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_86():
    result = parse("C*15:86")
    assert result.__class__ is Allele, f'Expected parse("C*15:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_87():
    result = parse("C*15:87")
    assert result.__class__ is Allele, f'Expected parse("C*15:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_88():
    result = parse("C*15:88")
    assert result.__class__ is Allele, f'Expected parse("C*15:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_89():
    result = parse("C*15:89")
    assert result.__class__ is Allele, f'Expected parse("C*15:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_90():
    result = parse("C*15:90")
    assert result.__class__ is Allele, f'Expected parse("C*15:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_91():
    result = parse("C*15:91")
    assert result.__class__ is Allele, f'Expected parse("C*15:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_92N():
    result = parse("C*15:92N")
    assert result.__class__ is Allele, f'Expected parse("C*15:92N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:92N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_93():
    result = parse("C*15:93")
    assert result.__class__ is Allele, f'Expected parse("C*15:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_94():
    result = parse("C*15:94")
    assert result.__class__ is Allele, f'Expected parse("C*15:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_95N():
    result = parse("C*15:95N")
    assert result.__class__ is Allele, f'Expected parse("C*15:95N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:95N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_96Q():
    result = parse("C*15:96Q")
    assert result.__class__ is Allele, f'Expected parse("C*15:96Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:96Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_97():
    result = parse("C*15:97")
    assert result.__class__ is Allele, f'Expected parse("C*15:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_98():
    result = parse("C*15:98")
    assert result.__class__ is Allele, f'Expected parse("C*15:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_15_99():
    result = parse("C*15:99")
    assert result.__class__ is Allele, f'Expected parse("C*15:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*15:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_01():
    result = parse("C*16:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_02():
    result = parse("C*16:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_03():
    result = parse("C*16:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_04():
    result = parse("C*16:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_05():
    result = parse("C*16:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_06():
    result = parse("C*16:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_07():
    result = parse("C*16:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_08():
    result = parse("C*16:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_09():
    result = parse("C*16:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_10():
    result = parse("C*16:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_11():
    result = parse("C*16:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_12():
    result = parse("C*16:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_13():
    result = parse("C*16:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_14():
    result = parse("C*16:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_15():
    result = parse("C*16:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_16():
    result = parse("C*16:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_17():
    result = parse("C*16:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_18():
    result = parse("C*16:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_01_19():
    result = parse("C*16:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_02():
    result = parse("C*16:01:02")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_03():
    result = parse("C*16:01:03")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_04():
    result = parse("C*16:01:04")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_05():
    result = parse("C*16:01:05")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_06():
    result = parse("C*16:01:06")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_07():
    result = parse("C*16:01:07")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_08():
    result = parse("C*16:01:08")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_09():
    result = parse("C*16:01:09")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_10():
    result = parse("C*16:01:10")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_11():
    result = parse("C*16:01:11")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_12():
    result = parse("C*16:01:12")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_13():
    result = parse("C*16:01:13")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_14():
    result = parse("C*16:01:14")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_15():
    result = parse("C*16:01:15")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_16():
    result = parse("C*16:01:16")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_17():
    result = parse("C*16:01:17")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_18():
    result = parse("C*16:01:18")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_19():
    result = parse("C*16:01:19")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_20():
    result = parse("C*16:01:20")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_21():
    result = parse("C*16:01:21")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_22():
    result = parse("C*16:01:22")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_23():
    result = parse("C*16:01:23")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_24():
    result = parse("C*16:01:24")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_25():
    result = parse("C*16:01:25")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_26():
    result = parse("C*16:01:26")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_27():
    result = parse("C*16:01:27")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_28():
    result = parse("C*16:01:28")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_29():
    result = parse("C*16:01:29")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_30():
    result = parse("C*16:01:30")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_31():
    result = parse("C*16:01:31")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_32():
    result = parse("C*16:01:32")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_33():
    result = parse("C*16:01:33")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_34():
    result = parse("C*16:01:34")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_35():
    result = parse("C*16:01:35")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_36():
    result = parse("C*16:01:36")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_37():
    result = parse("C*16:01:37")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_38():
    result = parse("C*16:01:38")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_01_39():
    result = parse("C*16:01:39")
    assert result.__class__ is Allele, f'Expected parse("C*16:01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_01_01():
    result = parse("C*16:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_01_02():
    result = parse("C*16:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_01_03():
    result = parse("C*16:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_02():
    result = parse("C*16:02:02")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_03():
    result = parse("C*16:02:03")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_04():
    result = parse("C*16:02:04")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_05():
    result = parse("C*16:02:05")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_06():
    result = parse("C*16:02:06")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_07():
    result = parse("C*16:02:07")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_08():
    result = parse("C*16:02:08")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_09():
    result = parse("C*16:02:09")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_10():
    result = parse("C*16:02:10")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_11():
    result = parse("C*16:02:11")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_12():
    result = parse("C*16:02:12")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_13():
    result = parse("C*16:02:13")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_14():
    result = parse("C*16:02:14")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_15():
    result = parse("C*16:02:15")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_16():
    result = parse("C*16:02:16")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_17():
    result = parse("C*16:02:17")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_02_18():
    result = parse("C*16:02:18")
    assert result.__class__ is Allele, f'Expected parse("C*16:02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_04_01_01():
    result = parse("C*16:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_04_01_02():
    result = parse("C*16:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_04_01_03():
    result = parse("C*16:04:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*16:04:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*16:04:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_04_03():
    result = parse("C*16:04:03")
    assert result.__class__ is Allele, f'Expected parse("C*16:04:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_04_04():
    result = parse("C*16:04:04")
    assert result.__class__ is Allele, f'Expected parse("C*16:04:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:04:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_04_05():
    result = parse("C*16:04:05")
    assert result.__class__ is Allele, f'Expected parse("C*16:04:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:04:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_06():
    result = parse("C*16:06")
    assert result.__class__ is Allele, f'Expected parse("C*16:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_07_01():
    result = parse("C*16:07:01")
    assert result.__class__ is Allele, f'Expected parse("C*16:07:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_07_02():
    result = parse("C*16:07:02")
    assert result.__class__ is Allele, f'Expected parse("C*16:07:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_08():
    result = parse("C*16:08")
    assert result.__class__ is Allele, f'Expected parse("C*16:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_09():
    result = parse("C*16:09")
    assert result.__class__ is Allele, f'Expected parse("C*16:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_10():
    result = parse("C*16:10")
    assert result.__class__ is Allele, f'Expected parse("C*16:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_100():
    result = parse("C*16:100")
    assert result.__class__ is Allele, f'Expected parse("C*16:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_101():
    result = parse("C*16:101")
    assert result.__class__ is Allele, f'Expected parse("C*16:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_102():
    result = parse("C*16:102")
    assert result.__class__ is Allele, f'Expected parse("C*16:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_103():
    result = parse("C*16:103")
    assert result.__class__ is Allele, f'Expected parse("C*16:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_104():
    result = parse("C*16:104")
    assert result.__class__ is Allele, f'Expected parse("C*16:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_105():
    result = parse("C*16:105")
    assert result.__class__ is Allele, f'Expected parse("C*16:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_106():
    result = parse("C*16:106")
    assert result.__class__ is Allele, f'Expected parse("C*16:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_107():
    result = parse("C*16:107")
    assert result.__class__ is Allele, f'Expected parse("C*16:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_108():
    result = parse("C*16:108")
    assert result.__class__ is Allele, f'Expected parse("C*16:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_109():
    result = parse("C*16:109")
    assert result.__class__ is Allele, f'Expected parse("C*16:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_11():
    result = parse("C*16:11")
    assert result.__class__ is Allele, f'Expected parse("C*16:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_110():
    result = parse("C*16:110")
    assert result.__class__ is Allele, f'Expected parse("C*16:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_111():
    result = parse("C*16:111")
    assert result.__class__ is Allele, f'Expected parse("C*16:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_112():
    result = parse("C*16:112")
    assert result.__class__ is Allele, f'Expected parse("C*16:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_113():
    result = parse("C*16:113")
    assert result.__class__ is Allele, f'Expected parse("C*16:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_114():
    result = parse("C*16:114")
    assert result.__class__ is Allele, f'Expected parse("C*16:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_115():
    result = parse("C*16:115")
    assert result.__class__ is Allele, f'Expected parse("C*16:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_116():
    result = parse("C*16:116")
    assert result.__class__ is Allele, f'Expected parse("C*16:116") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_117():
    result = parse("C*16:117")
    assert result.__class__ is Allele, f'Expected parse("C*16:117") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_118():
    result = parse("C*16:118")
    assert result.__class__ is Allele, f'Expected parse("C*16:118") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_119():
    result = parse("C*16:119")
    assert result.__class__ is Allele, f'Expected parse("C*16:119") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_12():
    result = parse("C*16:12")
    assert result.__class__ is Allele, f'Expected parse("C*16:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_120():
    result = parse("C*16:120")
    assert result.__class__ is Allele, f'Expected parse("C*16:120") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_121():
    result = parse("C*16:121")
    assert result.__class__ is Allele, f'Expected parse("C*16:121") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_122():
    result = parse("C*16:122")
    assert result.__class__ is Allele, f'Expected parse("C*16:122") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_123N():
    result = parse("C*16:123N")
    assert result.__class__ is Allele, f'Expected parse("C*16:123N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:123N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_124():
    result = parse("C*16:124")
    assert result.__class__ is Allele, f'Expected parse("C*16:124") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_125():
    result = parse("C*16:125")
    assert result.__class__ is Allele, f'Expected parse("C*16:125") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_126():
    result = parse("C*16:126")
    assert result.__class__ is Allele, f'Expected parse("C*16:126") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_127():
    result = parse("C*16:127")
    assert result.__class__ is Allele, f'Expected parse("C*16:127") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_128():
    result = parse("C*16:128")
    assert result.__class__ is Allele, f'Expected parse("C*16:128") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_129():
    result = parse("C*16:129")
    assert result.__class__ is Allele, f'Expected parse("C*16:129") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_13():
    result = parse("C*16:13")
    assert result.__class__ is Allele, f'Expected parse("C*16:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_130():
    result = parse("C*16:130")
    assert result.__class__ is Allele, f'Expected parse("C*16:130") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_131():
    result = parse("C*16:131")
    assert result.__class__ is Allele, f'Expected parse("C*16:131") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_132N():
    result = parse("C*16:132N")
    assert result.__class__ is Allele, f'Expected parse("C*16:132N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:132N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_133():
    result = parse("C*16:133")
    assert result.__class__ is Allele, f'Expected parse("C*16:133") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_134():
    result = parse("C*16:134")
    assert result.__class__ is Allele, f'Expected parse("C*16:134") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_135():
    result = parse("C*16:135")
    assert result.__class__ is Allele, f'Expected parse("C*16:135") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_136():
    result = parse("C*16:136")
    assert result.__class__ is Allele, f'Expected parse("C*16:136") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_137():
    result = parse("C*16:137")
    assert result.__class__ is Allele, f'Expected parse("C*16:137") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_138():
    result = parse("C*16:138")
    assert result.__class__ is Allele, f'Expected parse("C*16:138") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_139():
    result = parse("C*16:139")
    assert result.__class__ is Allele, f'Expected parse("C*16:139") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_14():
    result = parse("C*16:14")
    assert result.__class__ is Allele, f'Expected parse("C*16:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_140():
    result = parse("C*16:140")
    assert result.__class__ is Allele, f'Expected parse("C*16:140") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_141():
    result = parse("C*16:141")
    assert result.__class__ is Allele, f'Expected parse("C*16:141") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_142():
    result = parse("C*16:142")
    assert result.__class__ is Allele, f'Expected parse("C*16:142") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_143():
    result = parse("C*16:143")
    assert result.__class__ is Allele, f'Expected parse("C*16:143") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_144():
    result = parse("C*16:144")
    assert result.__class__ is Allele, f'Expected parse("C*16:144") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_145():
    result = parse("C*16:145")
    assert result.__class__ is Allele, f'Expected parse("C*16:145") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_146():
    result = parse("C*16:146")
    assert result.__class__ is Allele, f'Expected parse("C*16:146") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_147():
    result = parse("C*16:147")
    assert result.__class__ is Allele, f'Expected parse("C*16:147") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_148():
    result = parse("C*16:148")
    assert result.__class__ is Allele, f'Expected parse("C*16:148") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_149():
    result = parse("C*16:149")
    assert result.__class__ is Allele, f'Expected parse("C*16:149") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_150():
    result = parse("C*16:150")
    assert result.__class__ is Allele, f'Expected parse("C*16:150") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_151():
    result = parse("C*16:151")
    assert result.__class__ is Allele, f'Expected parse("C*16:151") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_152():
    result = parse("C*16:152")
    assert result.__class__ is Allele, f'Expected parse("C*16:152") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_153():
    result = parse("C*16:153")
    assert result.__class__ is Allele, f'Expected parse("C*16:153") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_154():
    result = parse("C*16:154")
    assert result.__class__ is Allele, f'Expected parse("C*16:154") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_155():
    result = parse("C*16:155")
    assert result.__class__ is Allele, f'Expected parse("C*16:155") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_156():
    result = parse("C*16:156")
    assert result.__class__ is Allele, f'Expected parse("C*16:156") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_157():
    result = parse("C*16:157")
    assert result.__class__ is Allele, f'Expected parse("C*16:157") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_158():
    result = parse("C*16:158")
    assert result.__class__ is Allele, f'Expected parse("C*16:158") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_159():
    result = parse("C*16:159")
    assert result.__class__ is Allele, f'Expected parse("C*16:159") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_15_01():
    result = parse("C*16:15:01")
    assert result.__class__ is Allele, f'Expected parse("C*16:15:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:15:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_15_02():
    result = parse("C*16:15:02")
    assert result.__class__ is Allele, f'Expected parse("C*16:15:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:15:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_160():
    result = parse("C*16:160")
    assert result.__class__ is Allele, f'Expected parse("C*16:160") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_161():
    result = parse("C*16:161")
    assert result.__class__ is Allele, f'Expected parse("C*16:161") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_162():
    result = parse("C*16:162")
    assert result.__class__ is Allele, f'Expected parse("C*16:162") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_163():
    result = parse("C*16:163")
    assert result.__class__ is Allele, f'Expected parse("C*16:163") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_164():
    result = parse("C*16:164")
    assert result.__class__ is Allele, f'Expected parse("C*16:164") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_165():
    result = parse("C*16:165")
    assert result.__class__ is Allele, f'Expected parse("C*16:165") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_166():
    result = parse("C*16:166")
    assert result.__class__ is Allele, f'Expected parse("C*16:166") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_167():
    result = parse("C*16:167")
    assert result.__class__ is Allele, f'Expected parse("C*16:167") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_168():
    result = parse("C*16:168")
    assert result.__class__ is Allele, f'Expected parse("C*16:168") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_169():
    result = parse("C*16:169")
    assert result.__class__ is Allele, f'Expected parse("C*16:169") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_16Q():
    result = parse("C*16:16Q")
    assert result.__class__ is Allele, f'Expected parse("C*16:16Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:16Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_17():
    result = parse("C*16:17")
    assert result.__class__ is Allele, f'Expected parse("C*16:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_170():
    result = parse("C*16:170")
    assert result.__class__ is Allele, f'Expected parse("C*16:170") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_171():
    result = parse("C*16:171")
    assert result.__class__ is Allele, f'Expected parse("C*16:171") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_172():
    result = parse("C*16:172")
    assert result.__class__ is Allele, f'Expected parse("C*16:172") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_173():
    result = parse("C*16:173")
    assert result.__class__ is Allele, f'Expected parse("C*16:173") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_18():
    result = parse("C*16:18")
    assert result.__class__ is Allele, f'Expected parse("C*16:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_19():
    result = parse("C*16:19")
    assert result.__class__ is Allele, f'Expected parse("C*16:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_20():
    result = parse("C*16:20")
    assert result.__class__ is Allele, f'Expected parse("C*16:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_21():
    result = parse("C*16:21")
    assert result.__class__ is Allele, f'Expected parse("C*16:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_22():
    result = parse("C*16:22")
    assert result.__class__ is Allele, f'Expected parse("C*16:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_23():
    result = parse("C*16:23")
    assert result.__class__ is Allele, f'Expected parse("C*16:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_24():
    result = parse("C*16:24")
    assert result.__class__ is Allele, f'Expected parse("C*16:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_25():
    result = parse("C*16:25")
    assert result.__class__ is Allele, f'Expected parse("C*16:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_26():
    result = parse("C*16:26")
    assert result.__class__ is Allele, f'Expected parse("C*16:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_27():
    result = parse("C*16:27")
    assert result.__class__ is Allele, f'Expected parse("C*16:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_28():
    result = parse("C*16:28")
    assert result.__class__ is Allele, f'Expected parse("C*16:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_29():
    result = parse("C*16:29")
    assert result.__class__ is Allele, f'Expected parse("C*16:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_30N():
    result = parse("C*16:30N")
    assert result.__class__ is Allele, f'Expected parse("C*16:30N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:30N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_31():
    result = parse("C*16:31")
    assert result.__class__ is Allele, f'Expected parse("C*16:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_32():
    result = parse("C*16:32")
    assert result.__class__ is Allele, f'Expected parse("C*16:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_33():
    result = parse("C*16:33")
    assert result.__class__ is Allele, f'Expected parse("C*16:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_34():
    result = parse("C*16:34")
    assert result.__class__ is Allele, f'Expected parse("C*16:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_35():
    result = parse("C*16:35")
    assert result.__class__ is Allele, f'Expected parse("C*16:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_36():
    result = parse("C*16:36")
    assert result.__class__ is Allele, f'Expected parse("C*16:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_37():
    result = parse("C*16:37")
    assert result.__class__ is Allele, f'Expected parse("C*16:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_38():
    result = parse("C*16:38")
    assert result.__class__ is Allele, f'Expected parse("C*16:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_39_01():
    result = parse("C*16:39:01")
    assert result.__class__ is Allele, f'Expected parse("C*16:39:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:39:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_39_02():
    result = parse("C*16:39:02")
    assert result.__class__ is Allele, f'Expected parse("C*16:39:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*16:39:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_40():
    result = parse("C*16:40")
    assert result.__class__ is Allele, f'Expected parse("C*16:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_41():
    result = parse("C*16:41")
    assert result.__class__ is Allele, f'Expected parse("C*16:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_42():
    result = parse("C*16:42")
    assert result.__class__ is Allele, f'Expected parse("C*16:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_43():
    result = parse("C*16:43")
    assert result.__class__ is Allele, f'Expected parse("C*16:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_44():
    result = parse("C*16:44")
    assert result.__class__ is Allele, f'Expected parse("C*16:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_45():
    result = parse("C*16:45")
    assert result.__class__ is Allele, f'Expected parse("C*16:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_46():
    result = parse("C*16:46")
    assert result.__class__ is Allele, f'Expected parse("C*16:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_47():
    result = parse("C*16:47")
    assert result.__class__ is Allele, f'Expected parse("C*16:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_48():
    result = parse("C*16:48")
    assert result.__class__ is Allele, f'Expected parse("C*16:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_49():
    result = parse("C*16:49")
    assert result.__class__ is Allele, f'Expected parse("C*16:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_50():
    result = parse("C*16:50")
    assert result.__class__ is Allele, f'Expected parse("C*16:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_51():
    result = parse("C*16:51")
    assert result.__class__ is Allele, f'Expected parse("C*16:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_52():
    result = parse("C*16:52")
    assert result.__class__ is Allele, f'Expected parse("C*16:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_53():
    result = parse("C*16:53")
    assert result.__class__ is Allele, f'Expected parse("C*16:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_54():
    result = parse("C*16:54")
    assert result.__class__ is Allele, f'Expected parse("C*16:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_55():
    result = parse("C*16:55")
    assert result.__class__ is Allele, f'Expected parse("C*16:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_56():
    result = parse("C*16:56")
    assert result.__class__ is Allele, f'Expected parse("C*16:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_57():
    result = parse("C*16:57")
    assert result.__class__ is Allele, f'Expected parse("C*16:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_58():
    result = parse("C*16:58")
    assert result.__class__ is Allele, f'Expected parse("C*16:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_59():
    result = parse("C*16:59")
    assert result.__class__ is Allele, f'Expected parse("C*16:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_60():
    result = parse("C*16:60")
    assert result.__class__ is Allele, f'Expected parse("C*16:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_61():
    result = parse("C*16:61")
    assert result.__class__ is Allele, f'Expected parse("C*16:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_62():
    result = parse("C*16:62")
    assert result.__class__ is Allele, f'Expected parse("C*16:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_63():
    result = parse("C*16:63")
    assert result.__class__ is Allele, f'Expected parse("C*16:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_64():
    result = parse("C*16:64")
    assert result.__class__ is Allele, f'Expected parse("C*16:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_65():
    result = parse("C*16:65")
    assert result.__class__ is Allele, f'Expected parse("C*16:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_66():
    result = parse("C*16:66")
    assert result.__class__ is Allele, f'Expected parse("C*16:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_67():
    result = parse("C*16:67")
    assert result.__class__ is Allele, f'Expected parse("C*16:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_68():
    result = parse("C*16:68")
    assert result.__class__ is Allele, f'Expected parse("C*16:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_69():
    result = parse("C*16:69")
    assert result.__class__ is Allele, f'Expected parse("C*16:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_70():
    result = parse("C*16:70")
    assert result.__class__ is Allele, f'Expected parse("C*16:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_71():
    result = parse("C*16:71")
    assert result.__class__ is Allele, f'Expected parse("C*16:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_72():
    result = parse("C*16:72")
    assert result.__class__ is Allele, f'Expected parse("C*16:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_73():
    result = parse("C*16:73")
    assert result.__class__ is Allele, f'Expected parse("C*16:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_74():
    result = parse("C*16:74")
    assert result.__class__ is Allele, f'Expected parse("C*16:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_75():
    result = parse("C*16:75")
    assert result.__class__ is Allele, f'Expected parse("C*16:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_76():
    result = parse("C*16:76")
    assert result.__class__ is Allele, f'Expected parse("C*16:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_77N():
    result = parse("C*16:77N")
    assert result.__class__ is Allele, f'Expected parse("C*16:77N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:77N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_78():
    result = parse("C*16:78")
    assert result.__class__ is Allele, f'Expected parse("C*16:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_79():
    result = parse("C*16:79")
    assert result.__class__ is Allele, f'Expected parse("C*16:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_80():
    result = parse("C*16:80")
    assert result.__class__ is Allele, f'Expected parse("C*16:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_81():
    result = parse("C*16:81")
    assert result.__class__ is Allele, f'Expected parse("C*16:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_82():
    result = parse("C*16:82")
    assert result.__class__ is Allele, f'Expected parse("C*16:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_83():
    result = parse("C*16:83")
    assert result.__class__ is Allele, f'Expected parse("C*16:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_84():
    result = parse("C*16:84")
    assert result.__class__ is Allele, f'Expected parse("C*16:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_85():
    result = parse("C*16:85")
    assert result.__class__ is Allele, f'Expected parse("C*16:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_86():
    result = parse("C*16:86")
    assert result.__class__ is Allele, f'Expected parse("C*16:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_87():
    result = parse("C*16:87")
    assert result.__class__ is Allele, f'Expected parse("C*16:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_88():
    result = parse("C*16:88")
    assert result.__class__ is Allele, f'Expected parse("C*16:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_89N():
    result = parse("C*16:89N")
    assert result.__class__ is Allele, f'Expected parse("C*16:89N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:89N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_90():
    result = parse("C*16:90")
    assert result.__class__ is Allele, f'Expected parse("C*16:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_91():
    result = parse("C*16:91")
    assert result.__class__ is Allele, f'Expected parse("C*16:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_92():
    result = parse("C*16:92")
    assert result.__class__ is Allele, f'Expected parse("C*16:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_93():
    result = parse("C*16:93")
    assert result.__class__ is Allele, f'Expected parse("C*16:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_94():
    result = parse("C*16:94")
    assert result.__class__ is Allele, f'Expected parse("C*16:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_95():
    result = parse("C*16:95")
    assert result.__class__ is Allele, f'Expected parse("C*16:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_96():
    result = parse("C*16:96")
    assert result.__class__ is Allele, f'Expected parse("C*16:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_97():
    result = parse("C*16:97")
    assert result.__class__ is Allele, f'Expected parse("C*16:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_98():
    result = parse("C*16:98")
    assert result.__class__ is Allele, f'Expected parse("C*16:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_16_99():
    result = parse("C*16:99")
    assert result.__class__ is Allele, f'Expected parse("C*16:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*16:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_01_02():
    result = parse("C*17:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_01_03():
    result = parse("C*17:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_01_04():
    result = parse("C*17:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_01_05():
    result = parse("C*17:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_01_06():
    result = parse("C*17:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_01_07():
    result = parse("C*17:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_01_08():
    result = parse("C*17:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_01_09():
    result = parse("C*17:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_01_10():
    result = parse("C*17:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_01_11():
    result = parse("C*17:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_01_12():
    result = parse("C*17:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_02():
    result = parse("C*17:01:02")
    assert result.__class__ is Allele, f'Expected parse("C*17:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_03():
    result = parse("C*17:01:03")
    assert result.__class__ is Allele, f'Expected parse("C*17:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_04():
    result = parse("C*17:01:04")
    assert result.__class__ is Allele, f'Expected parse("C*17:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_05():
    result = parse("C*17:01:05")
    assert result.__class__ is Allele, f'Expected parse("C*17:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_06():
    result = parse("C*17:01:06")
    assert result.__class__ is Allele, f'Expected parse("C*17:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_07():
    result = parse("C*17:01:07")
    assert result.__class__ is Allele, f'Expected parse("C*17:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_08():
    result = parse("C*17:01:08")
    assert result.__class__ is Allele, f'Expected parse("C*17:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_09():
    result = parse("C*17:01:09")
    assert result.__class__ is Allele, f'Expected parse("C*17:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_10():
    result = parse("C*17:01:10")
    assert result.__class__ is Allele, f'Expected parse("C*17:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_11():
    result = parse("C*17:01:11")
    assert result.__class__ is Allele, f'Expected parse("C*17:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_12():
    result = parse("C*17:01:12")
    assert result.__class__ is Allele, f'Expected parse("C*17:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_13():
    result = parse("C*17:01:13")
    assert result.__class__ is Allele, f'Expected parse("C*17:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_14():
    result = parse("C*17:01:14")
    assert result.__class__ is Allele, f'Expected parse("C*17:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_15():
    result = parse("C*17:01:15")
    assert result.__class__ is Allele, f'Expected parse("C*17:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_01_16():
    result = parse("C*17:01:16")
    assert result.__class__ is Allele, f'Expected parse("C*17:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_02():
    result = parse("C*17:02")
    assert result.__class__ is Allele, f'Expected parse("C*17:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_03_01_01():
    result = parse("C*17:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_03_01_02():
    result = parse("C*17:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_03_01_03():
    result = parse("C*17:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_03_01_04():
    result = parse("C*17:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_03_01_05():
    result = parse("C*17:03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:03:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_03_02():
    result = parse("C*17:03:02")
    assert result.__class__ is Allele, f'Expected parse("C*17:03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_03_03():
    result = parse("C*17:03:03")
    assert result.__class__ is Allele, f'Expected parse("C*17:03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_04():
    result = parse("C*17:04")
    assert result.__class__ is Allele, f'Expected parse("C*17:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_05():
    result = parse("C*17:05")
    assert result.__class__ is Allele, f'Expected parse("C*17:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_06():
    result = parse("C*17:06")
    assert result.__class__ is Allele, f'Expected parse("C*17:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_07():
    result = parse("C*17:07")
    assert result.__class__ is Allele, f'Expected parse("C*17:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_08():
    result = parse("C*17:08")
    assert result.__class__ is Allele, f'Expected parse("C*17:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_09():
    result = parse("C*17:09")
    assert result.__class__ is Allele, f'Expected parse("C*17:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_10():
    result = parse("C*17:10")
    assert result.__class__ is Allele, f'Expected parse("C*17:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_11():
    result = parse("C*17:11")
    assert result.__class__ is Allele, f'Expected parse("C*17:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_12():
    result = parse("C*17:12")
    assert result.__class__ is Allele, f'Expected parse("C*17:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_13():
    result = parse("C*17:13")
    assert result.__class__ is Allele, f'Expected parse("C*17:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_14():
    result = parse("C*17:14")
    assert result.__class__ is Allele, f'Expected parse("C*17:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_15():
    result = parse("C*17:15")
    assert result.__class__ is Allele, f'Expected parse("C*17:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_16_01():
    result = parse("C*17:16:01")
    assert result.__class__ is Allele, f'Expected parse("C*17:16:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:16:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_16_02():
    result = parse("C*17:16:02")
    assert result.__class__ is Allele, f'Expected parse("C*17:16:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:16:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_17():
    result = parse("C*17:17")
    assert result.__class__ is Allele, f'Expected parse("C*17:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_18():
    result = parse("C*17:18")
    assert result.__class__ is Allele, f'Expected parse("C*17:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_19():
    result = parse("C*17:19")
    assert result.__class__ is Allele, f'Expected parse("C*17:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_20():
    result = parse("C*17:20")
    assert result.__class__ is Allele, f'Expected parse("C*17:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_21():
    result = parse("C*17:21")
    assert result.__class__ is Allele, f'Expected parse("C*17:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_22():
    result = parse("C*17:22")
    assert result.__class__ is Allele, f'Expected parse("C*17:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_23():
    result = parse("C*17:23")
    assert result.__class__ is Allele, f'Expected parse("C*17:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_24():
    result = parse("C*17:24")
    assert result.__class__ is Allele, f'Expected parse("C*17:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_25():
    result = parse("C*17:25")
    assert result.__class__ is Allele, f'Expected parse("C*17:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_26():
    result = parse("C*17:26")
    assert result.__class__ is Allele, f'Expected parse("C*17:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_27N():
    result = parse("C*17:27N")
    assert result.__class__ is Allele, f'Expected parse("C*17:27N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:27N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_28():
    result = parse("C*17:28")
    assert result.__class__ is Allele, f'Expected parse("C*17:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_29():
    result = parse("C*17:29")
    assert result.__class__ is Allele, f'Expected parse("C*17:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_30():
    result = parse("C*17:30")
    assert result.__class__ is Allele, f'Expected parse("C*17:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_31():
    result = parse("C*17:31")
    assert result.__class__ is Allele, f'Expected parse("C*17:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_32():
    result = parse("C*17:32")
    assert result.__class__ is Allele, f'Expected parse("C*17:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_33():
    result = parse("C*17:33")
    assert result.__class__ is Allele, f'Expected parse("C*17:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_34():
    result = parse("C*17:34")
    assert result.__class__ is Allele, f'Expected parse("C*17:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_35():
    result = parse("C*17:35")
    assert result.__class__ is Allele, f'Expected parse("C*17:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_36():
    result = parse("C*17:36")
    assert result.__class__ is Allele, f'Expected parse("C*17:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_37():
    result = parse("C*17:37")
    assert result.__class__ is Allele, f'Expected parse("C*17:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_38_01_01():
    result = parse("C*17:38:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:38:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:38:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_38_01_02():
    result = parse("C*17:38:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:38:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:38:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_39():
    result = parse("C*17:39")
    assert result.__class__ is Allele, f'Expected parse("C*17:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_40():
    result = parse("C*17:40")
    assert result.__class__ is Allele, f'Expected parse("C*17:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_41():
    result = parse("C*17:41")
    assert result.__class__ is Allele, f'Expected parse("C*17:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_42():
    result = parse("C*17:42")
    assert result.__class__ is Allele, f'Expected parse("C*17:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_43():
    result = parse("C*17:43")
    assert result.__class__ is Allele, f'Expected parse("C*17:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_44():
    result = parse("C*17:44")
    assert result.__class__ is Allele, f'Expected parse("C*17:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_45():
    result = parse("C*17:45")
    assert result.__class__ is Allele, f'Expected parse("C*17:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_46():
    result = parse("C*17:46")
    assert result.__class__ is Allele, f'Expected parse("C*17:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_47():
    result = parse("C*17:47")
    assert result.__class__ is Allele, f'Expected parse("C*17:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_48():
    result = parse("C*17:48")
    assert result.__class__ is Allele, f'Expected parse("C*17:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_49():
    result = parse("C*17:49")
    assert result.__class__ is Allele, f'Expected parse("C*17:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_50():
    result = parse("C*17:50")
    assert result.__class__ is Allele, f'Expected parse("C*17:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_51_01_01():
    result = parse("C*17:51:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:51:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:51:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_51_01_02():
    result = parse("C*17:51:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*17:51:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*17:51:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_51_02():
    result = parse("C*17:51:02")
    assert result.__class__ is Allele, f'Expected parse("C*17:51:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*17:51:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_52():
    result = parse("C*17:52")
    assert result.__class__ is Allele, f'Expected parse("C*17:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_53():
    result = parse("C*17:53")
    assert result.__class__ is Allele, f'Expected parse("C*17:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_17_54():
    result = parse("C*17:54")
    assert result.__class__ is Allele, f'Expected parse("C*17:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*17:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_01_01_01():
    result = parse("C*18:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*18:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*18:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_01_01_02():
    result = parse("C*18:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*18:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*18:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_01_01_03():
    result = parse("C*18:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*18:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*18:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_01_02():
    result = parse("C*18:01:02")
    assert result.__class__ is Allele, f'Expected parse("C*18:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*18:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_02_01_01():
    result = parse("C*18:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("C*18:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*18:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_02_01_02():
    result = parse("C*18:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("C*18:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*18:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_02_01_03():
    result = parse("C*18:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("C*18:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("C*18:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_02_02():
    result = parse("C*18:02:02")
    assert result.__class__ is Allele, f'Expected parse("C*18:02:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*18:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_02_03():
    result = parse("C*18:02:03")
    assert result.__class__ is Allele, f'Expected parse("C*18:02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*18:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_02_04():
    result = parse("C*18:02:04")
    assert result.__class__ is Allele, f'Expected parse("C*18:02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*18:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_02_05():
    result = parse("C*18:02:05")
    assert result.__class__ is Allele, f'Expected parse("C*18:02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("C*18:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_03():
    result = parse("C*18:03")
    assert result.__class__ is Allele, f'Expected parse("C*18:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*18:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_04():
    result = parse("C*18:04")
    assert result.__class__ is Allele, f'Expected parse("C*18:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*18:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_05():
    result = parse("C*18:05")
    assert result.__class__ is Allele, f'Expected parse("C*18:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*18:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_06():
    result = parse("C*18:06")
    assert result.__class__ is Allele, f'Expected parse("C*18:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*18:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_07N():
    result = parse("C*18:07N")
    assert result.__class__ is Allele, f'Expected parse("C*18:07N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*18:07N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_08():
    result = parse("C*18:08")
    assert result.__class__ is Allele, f'Expected parse("C*18:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*18:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_09():
    result = parse("C*18:09")
    assert result.__class__ is Allele, f'Expected parse("C*18:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*18:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_10():
    result = parse("C*18:10")
    assert result.__class__ is Allele, f'Expected parse("C*18:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*18:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_11():
    result = parse("C*18:11")
    assert result.__class__ is Allele, f'Expected parse("C*18:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*18:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_12():
    result = parse("C*18:12")
    assert result.__class__ is Allele, f'Expected parse("C*18:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*18:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_13():
    result = parse("C*18:13")
    assert result.__class__ is Allele, f'Expected parse("C*18:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*18:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_C_18_14():
    result = parse("C*18:14")
    assert result.__class__ is Allele, f'Expected parse("C*18:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("C*18:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMA_01_01_01_01():
    result = parse("DMA*01:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DMA*01:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DMA*01:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMA_01_01_01_02():
    result = parse("DMA*01:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DMA*01:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DMA*01:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMA_01_01_01_03():
    result = parse("DMA*01:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DMA*01:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DMA*01:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMA_01_01_01_04():
    result = parse("DMA*01:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DMA*01:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DMA*01:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMA_01_02():
    result = parse("DMA*01:02")
    assert result.__class__ is Allele, f'Expected parse("DMA*01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DMA*01:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMA_01_03():
    result = parse("DMA*01:03")
    assert result.__class__ is Allele, f'Expected parse("DMA*01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DMA*01:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMA_01_04():
    result = parse("DMA*01:04")
    assert result.__class__ is Allele, f'Expected parse("DMA*01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DMA*01:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOA_01_01_01():
    result = parse("DOA*01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DOA*01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DOA*01:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOA_01_01_02_01():
    result = parse("DOA*01:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DOA*01:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DOA*01:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOA_01_01_02_02():
    result = parse("DOA*01:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DOA*01:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DOA*01:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOA_01_01_02_03():
    result = parse("DOA*01:01:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DOA*01:01:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DOA*01:01:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOA_01_01_03():
    result = parse("DOA*01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DOA*01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DOA*01:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOA_01_01_04_01():
    result = parse("DOA*01:01:04:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DOA*01:01:04:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DOA*01:01:04:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOA_01_01_04_02():
    result = parse("DOA*01:01:04:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DOA*01:01:04:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DOA*01:01:04:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOA_01_01_05():
    result = parse("DOA*01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DOA*01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DOA*01:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOA_01_01_06():
    result = parse("DOA*01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DOA*01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DOA*01:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOA_01_02():
    result = parse("DOA*01:02")
    assert result.__class__ is Allele, f'Expected parse("DOA*01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DOA*01:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOA_01_03():
    result = parse("DOA*01:03")
    assert result.__class__ is Allele, f'Expected parse("DOA*01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DOA*01:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOA_01_04N():
    result = parse("DOA*01:04N")
    assert result.__class__ is Allele, f'Expected parse("DOA*01:04N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DOA*01:04N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_01_01_01():
    result = parse("DRA*01:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_01_01_02():
    result = parse("DRA*01:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_01_01_03():
    result = parse("DRA*01:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_01_01_04():
    result = parse("DRA*01:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_01_01_05():
    result = parse("DRA*01:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_01_01_06():
    result = parse("DRA*01:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_01_01_07():
    result = parse("DRA*01:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_01_01_08():
    result = parse("DRA*01:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_01_01_09():
    result = parse("DRA*01:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_01_01_10():
    result = parse("DRA*01:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_01_01_11():
    result = parse("DRA*01:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_01_01_12():
    result = parse("DRA*01:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_01_02():
    result = parse("DRA*01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRA*01:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_02_01():
    result = parse("DRA*01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRA*01:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_02_02_01():
    result = parse("DRA*01:02:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:02:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:02:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_02_02_02():
    result = parse("DRA*01:02:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:02:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:02:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_02_02_03():
    result = parse("DRA*01:02:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:02:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:02:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_02_02_04():
    result = parse("DRA*01:02:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:02:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:02:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_02_02_05():
    result = parse("DRA*01:02:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:02:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:02:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_02_02_06():
    result = parse("DRA*01:02:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:02:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:02:02:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_02_02_07():
    result = parse("DRA*01:02:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:02:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:02:02:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_02_02_08():
    result = parse("DRA*01:02:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:02:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:02:02:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_02_02_09():
    result = parse("DRA*01:02:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:02:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:02:02:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_02_02_10():
    result = parse("DRA*01:02:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:02:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:02:02:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_02_02_11():
    result = parse("DRA*01:02:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:02:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:02:02:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_02_02_12():
    result = parse("DRA*01:02:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:02:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:02:02:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_02_02_13():
    result = parse("DRA*01:02:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:02:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:02:02:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_02_02_14():
    result = parse("DRA*01:02:02:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:02:02:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRA*01:02:02:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRA_01_02_03():
    result = parse("DRA*01:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRA*01:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRA*01:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMB_01_01_01_01():
    result = parse("DMB*01:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DMB*01:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DMB*01:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMB_01_01_01_02():
    result = parse("DMB*01:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DMB*01:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DMB*01:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMB_01_01_01_03():
    result = parse("DMB*01:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DMB*01:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DMB*01:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMB_01_01_01_04():
    result = parse("DMB*01:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DMB*01:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DMB*01:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMB_01_02():
    result = parse("DMB*01:02")
    assert result.__class__ is Allele, f'Expected parse("DMB*01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DMB*01:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMB_01_03_01_01():
    result = parse("DMB*01:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DMB*01:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DMB*01:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMB_01_03_01_02():
    result = parse("DMB*01:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DMB*01:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DMB*01:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMB_01_03_01_03():
    result = parse("DMB*01:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DMB*01:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DMB*01:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMB_01_03_01_04():
    result = parse("DMB*01:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DMB*01:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DMB*01:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMB_01_04():
    result = parse("DMB*01:04")
    assert result.__class__ is Allele, f'Expected parse("DMB*01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DMB*01:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMB_01_05():
    result = parse("DMB*01:05")
    assert result.__class__ is Allele, f'Expected parse("DMB*01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DMB*01:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMB_01_06():
    result = parse("DMB*01:06")
    assert result.__class__ is Allele, f'Expected parse("DMB*01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DMB*01:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DMB_01_07():
    result = parse("DMB*01:07")
    assert result.__class__ is Allele, f'Expected parse("DMB*01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DMB*01:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOB_01_01_01_01():
    result = parse("DOB*01:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DOB*01:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DOB*01:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOB_01_01_01_02():
    result = parse("DOB*01:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DOB*01:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DOB*01:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOB_01_01_01_03():
    result = parse("DOB*01:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DOB*01:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DOB*01:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOB_01_01_01_04():
    result = parse("DOB*01:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DOB*01:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DOB*01:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOB_01_01_02():
    result = parse("DOB*01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DOB*01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DOB*01:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOB_01_01_03_01():
    result = parse("DOB*01:01:03:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DOB*01:01:03:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DOB*01:01:03:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOB_01_01_03_02():
    result = parse("DOB*01:01:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DOB*01:01:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DOB*01:01:03:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOB_01_02_01():
    result = parse("DOB*01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DOB*01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DOB*01:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOB_01_02_02():
    result = parse("DOB*01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DOB*01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DOB*01:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOB_01_03():
    result = parse("DOB*01:03")
    assert result.__class__ is Allele, f'Expected parse("DOB*01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DOB*01:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOB_01_04_01_01():
    result = parse("DOB*01:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DOB*01:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DOB*01:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOB_01_04_01_02():
    result = parse("DOB*01:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DOB*01:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DOB*01:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DOB_01_05():
    result = parse("DOB*01:05")
    assert result.__class__ is Allele, f'Expected parse("DOB*01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DOB*01:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_01_01():
    result = parse("DRB1*01:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*01:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_01_02():
    result = parse("DRB1*01:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*01:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_02():
    result = parse("DRB1*01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_03():
    result = parse("DRB1*01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_04():
    result = parse("DRB1*01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_05():
    result = parse("DRB1*01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_06():
    result = parse("DRB1*01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_07():
    result = parse("DRB1*01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_08():
    result = parse("DRB1*01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_09():
    result = parse("DRB1*01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_10():
    result = parse("DRB1*01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_11():
    result = parse("DRB1*01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_12():
    result = parse("DRB1*01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_13():
    result = parse("DRB1*01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_14():
    result = parse("DRB1*01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_15():
    result = parse("DRB1*01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_16():
    result = parse("DRB1*01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_17():
    result = parse("DRB1*01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_18():
    result = parse("DRB1*01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_19():
    result = parse("DRB1*01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_20():
    result = parse("DRB1*01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_21():
    result = parse("DRB1*01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_22():
    result = parse("DRB1*01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_23():
    result = parse("DRB1*01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_24():
    result = parse("DRB1*01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_25():
    result = parse("DRB1*01:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_26():
    result = parse("DRB1*01:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_27():
    result = parse("DRB1*01:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_28():
    result = parse("DRB1*01:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_29():
    result = parse("DRB1*01:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_30():
    result = parse("DRB1*01:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_31():
    result = parse("DRB1*01:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_32():
    result = parse("DRB1*01:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_33():
    result = parse("DRB1*01:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_01_34():
    result = parse("DRB1*01:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_02_01_01():
    result = parse("DRB1*01:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*01:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_02_01_02():
    result = parse("DRB1*01:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*01:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_02_01_03():
    result = parse("DRB1*01:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*01:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_02_02():
    result = parse("DRB1*01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_02_03():
    result = parse("DRB1*01:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_02_04():
    result = parse("DRB1*01:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_02_05():
    result = parse("DRB1*01:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_02_06():
    result = parse("DRB1*01:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_02_07():
    result = parse("DRB1*01:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_02_08():
    result = parse("DRB1*01:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_02_09():
    result = parse("DRB1*01:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_02_10():
    result = parse("DRB1*01:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_02_11():
    result = parse("DRB1*01:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_02_12():
    result = parse("DRB1*01:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_02_13():
    result = parse("DRB1*01:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_03_01():
    result = parse("DRB1*01:03:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:03:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:03:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_03_02():
    result = parse("DRB1*01:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_03_03():
    result = parse("DRB1*01:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_03_04():
    result = parse("DRB1*01:03:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:03:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_04():
    result = parse("DRB1*01:04")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_05():
    result = parse("DRB1*01:05")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_06():
    result = parse("DRB1*01:06")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_07():
    result = parse("DRB1*01:07")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_08():
    result = parse("DRB1*01:08")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_09():
    result = parse("DRB1*01:09")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_10():
    result = parse("DRB1*01:10")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_100():
    result = parse("DRB1*01:100")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_101():
    result = parse("DRB1*01:101")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_102():
    result = parse("DRB1*01:102")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_103():
    result = parse("DRB1*01:103")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_104():
    result = parse("DRB1*01:104")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_105():
    result = parse("DRB1*01:105")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_106():
    result = parse("DRB1*01:106")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_107():
    result = parse("DRB1*01:107")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_108():
    result = parse("DRB1*01:108")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_109():
    result = parse("DRB1*01:109")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_110():
    result = parse("DRB1*01:110")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_111():
    result = parse("DRB1*01:111")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_112():
    result = parse("DRB1*01:112")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_113():
    result = parse("DRB1*01:113")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_114():
    result = parse("DRB1*01:114")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_115():
    result = parse("DRB1*01:115")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:115") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_11_01():
    result = parse("DRB1*01:11:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:11:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:11:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_11_02():
    result = parse("DRB1*01:11:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:11:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:11:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_12():
    result = parse("DRB1*01:12")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_13():
    result = parse("DRB1*01:13")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_14():
    result = parse("DRB1*01:14")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_15():
    result = parse("DRB1*01:15")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_16():
    result = parse("DRB1*01:16")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_17():
    result = parse("DRB1*01:17")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_18_01():
    result = parse("DRB1*01:18:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:18:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:18:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_18_02():
    result = parse("DRB1*01:18:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:18:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:18:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_19():
    result = parse("DRB1*01:19")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_20_01():
    result = parse("DRB1*01:20:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:20:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:20:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_20_02():
    result = parse("DRB1*01:20:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:20:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:20:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_21():
    result = parse("DRB1*01:21")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_22():
    result = parse("DRB1*01:22")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_23():
    result = parse("DRB1*01:23")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_24_01():
    result = parse("DRB1*01:24:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:24:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:24:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_24_02():
    result = parse("DRB1*01:24:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:24:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:24:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_25():
    result = parse("DRB1*01:25")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_26():
    result = parse("DRB1*01:26")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_27():
    result = parse("DRB1*01:27")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_28():
    result = parse("DRB1*01:28")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_29_01():
    result = parse("DRB1*01:29:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:29:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:29:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_29_02():
    result = parse("DRB1*01:29:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:29:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:29:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_30():
    result = parse("DRB1*01:30")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_31():
    result = parse("DRB1*01:31")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_32():
    result = parse("DRB1*01:32")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_33N():
    result = parse("DRB1*01:33N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:33N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:33N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_34():
    result = parse("DRB1*01:34")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_35():
    result = parse("DRB1*01:35")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_36():
    result = parse("DRB1*01:36")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_37():
    result = parse("DRB1*01:37")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_38():
    result = parse("DRB1*01:38")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_39N():
    result = parse("DRB1*01:39N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:39N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:39N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_40N():
    result = parse("DRB1*01:40N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:40N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:40N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_41():
    result = parse("DRB1*01:41")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_42():
    result = parse("DRB1*01:42")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_43():
    result = parse("DRB1*01:43")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_44_01():
    result = parse("DRB1*01:44:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:44:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:44:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_44_02():
    result = parse("DRB1*01:44:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:44:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:44:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_45():
    result = parse("DRB1*01:45")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_46():
    result = parse("DRB1*01:46")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_47():
    result = parse("DRB1*01:47")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_48():
    result = parse("DRB1*01:48")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_49():
    result = parse("DRB1*01:49")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_50():
    result = parse("DRB1*01:50")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_51():
    result = parse("DRB1*01:51")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_52N():
    result = parse("DRB1*01:52N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:52N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:52N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_53():
    result = parse("DRB1*01:53")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_54():
    result = parse("DRB1*01:54")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_55():
    result = parse("DRB1*01:55")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_56():
    result = parse("DRB1*01:56")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_57():
    result = parse("DRB1*01:57")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_58():
    result = parse("DRB1*01:58")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_59():
    result = parse("DRB1*01:59")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_60():
    result = parse("DRB1*01:60")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_61():
    result = parse("DRB1*01:61")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_62_01N():
    result = parse("DRB1*01:62:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:62:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:62:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_62_02N():
    result = parse("DRB1*01:62:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:62:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:62:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_63():
    result = parse("DRB1*01:63")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_64():
    result = parse("DRB1*01:64")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_65_01():
    result = parse("DRB1*01:65:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:65:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:65:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_65_02():
    result = parse("DRB1*01:65:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:65:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*01:65:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_66():
    result = parse("DRB1*01:66")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_67():
    result = parse("DRB1*01:67")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_68N():
    result = parse("DRB1*01:68N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:68N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:68N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_69():
    result = parse("DRB1*01:69")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_70():
    result = parse("DRB1*01:70")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_71():
    result = parse("DRB1*01:71")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_72():
    result = parse("DRB1*01:72")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_73():
    result = parse("DRB1*01:73")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_74():
    result = parse("DRB1*01:74")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_75():
    result = parse("DRB1*01:75")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_76():
    result = parse("DRB1*01:76")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_77():
    result = parse("DRB1*01:77")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_78():
    result = parse("DRB1*01:78")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_79():
    result = parse("DRB1*01:79")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_80():
    result = parse("DRB1*01:80")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_81():
    result = parse("DRB1*01:81")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_82():
    result = parse("DRB1*01:82")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_83():
    result = parse("DRB1*01:83")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_84():
    result = parse("DRB1*01:84")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_85():
    result = parse("DRB1*01:85")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_86():
    result = parse("DRB1*01:86")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_87():
    result = parse("DRB1*01:87")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_88():
    result = parse("DRB1*01:88")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_89():
    result = parse("DRB1*01:89")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_90():
    result = parse("DRB1*01:90")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_91Q():
    result = parse("DRB1*01:91Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*01:91Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:91Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_92():
    result = parse("DRB1*01:92")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_93():
    result = parse("DRB1*01:93")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_94():
    result = parse("DRB1*01:94")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_95():
    result = parse("DRB1*01:95")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_96():
    result = parse("DRB1*01:96")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_97():
    result = parse("DRB1*01:97")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_98():
    result = parse("DRB1*01:98")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_01_99():
    result = parse("DRB1*01:99")
    assert result.__class__ is Allele, f'Expected parse("DRB1*01:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*01:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_01_01():
    result = parse("DRB1*03:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*03:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_01_02():
    result = parse("DRB1*03:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*03:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_01_03():
    result = parse("DRB1*03:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*03:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_02():
    result = parse("DRB1*03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_03():
    result = parse("DRB1*03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_04():
    result = parse("DRB1*03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_05():
    result = parse("DRB1*03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_06():
    result = parse("DRB1*03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_07():
    result = parse("DRB1*03:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_08():
    result = parse("DRB1*03:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_09():
    result = parse("DRB1*03:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_10():
    result = parse("DRB1*03:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_11():
    result = parse("DRB1*03:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_12():
    result = parse("DRB1*03:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_13():
    result = parse("DRB1*03:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_14():
    result = parse("DRB1*03:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_15():
    result = parse("DRB1*03:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_16():
    result = parse("DRB1*03:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_17():
    result = parse("DRB1*03:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_18():
    result = parse("DRB1*03:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_19():
    result = parse("DRB1*03:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_20():
    result = parse("DRB1*03:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_21():
    result = parse("DRB1*03:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_22():
    result = parse("DRB1*03:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_23():
    result = parse("DRB1*03:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_24():
    result = parse("DRB1*03:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_25():
    result = parse("DRB1*03:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_26():
    result = parse("DRB1*03:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_27():
    result = parse("DRB1*03:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_28():
    result = parse("DRB1*03:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_29():
    result = parse("DRB1*03:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_01_30():
    result = parse("DRB1*03:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_02_01():
    result = parse("DRB1*03:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_02_02():
    result = parse("DRB1*03:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_02_03():
    result = parse("DRB1*03:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_02_04():
    result = parse("DRB1*03:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_03():
    result = parse("DRB1*03:03")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_04_01():
    result = parse("DRB1*03:04:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:04:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_04_02():
    result = parse("DRB1*03:04:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:04:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_05_01():
    result = parse("DRB1*03:05:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:05:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_05_02():
    result = parse("DRB1*03:05:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:05:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_05_03():
    result = parse("DRB1*03:05:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:05:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:05:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_06():
    result = parse("DRB1*03:06")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_07_01():
    result = parse("DRB1*03:07:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:07:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_07_02():
    result = parse("DRB1*03:07:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:07:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_08():
    result = parse("DRB1*03:08")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_09():
    result = parse("DRB1*03:09")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_10():
    result = parse("DRB1*03:10")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_100_01():
    result = parse("DRB1*03:100:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:100:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:100:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_100_02():
    result = parse("DRB1*03:100:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:100:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:100:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_101():
    result = parse("DRB1*03:101")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_102():
    result = parse("DRB1*03:102")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_103():
    result = parse("DRB1*03:103")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_104():
    result = parse("DRB1*03:104")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_105():
    result = parse("DRB1*03:105")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_106():
    result = parse("DRB1*03:106")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_107():
    result = parse("DRB1*03:107")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_108():
    result = parse("DRB1*03:108")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_109():
    result = parse("DRB1*03:109")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_110():
    result = parse("DRB1*03:110")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_111():
    result = parse("DRB1*03:111")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_112():
    result = parse("DRB1*03:112")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_113():
    result = parse("DRB1*03:113")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_114():
    result = parse("DRB1*03:114")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_115():
    result = parse("DRB1*03:115")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:115") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_116():
    result = parse("DRB1*03:116")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_117():
    result = parse("DRB1*03:117")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_118():
    result = parse("DRB1*03:118")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:118") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_119():
    result = parse("DRB1*03:119")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:119") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_11_01():
    result = parse("DRB1*03:11:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:11:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:11:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_12():
    result = parse("DRB1*03:12")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_120():
    result = parse("DRB1*03:120")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:120") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_121():
    result = parse("DRB1*03:121")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:121") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_122():
    result = parse("DRB1*03:122")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:122") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_123():
    result = parse("DRB1*03:123")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:123") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_124():
    result = parse("DRB1*03:124")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:124") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_125():
    result = parse("DRB1*03:125")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:125") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_126():
    result = parse("DRB1*03:126")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:126") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_127():
    result = parse("DRB1*03:127")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:127") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_128():
    result = parse("DRB1*03:128")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:128") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_129():
    result = parse("DRB1*03:129")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:129") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_130():
    result = parse("DRB1*03:130")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:130") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_131():
    result = parse("DRB1*03:131")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:131") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_132():
    result = parse("DRB1*03:132")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:132") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_133():
    result = parse("DRB1*03:133")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:133") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_134():
    result = parse("DRB1*03:134")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:134") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_135():
    result = parse("DRB1*03:135")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:135") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_136():
    result = parse("DRB1*03:136")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:136") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_137():
    result = parse("DRB1*03:137")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:137") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_138():
    result = parse("DRB1*03:138")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:138") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_139():
    result = parse("DRB1*03:139")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:139") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_13_01():
    result = parse("DRB1*03:13:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:13:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:13:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_13_02():
    result = parse("DRB1*03:13:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:13:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:13:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_14():
    result = parse("DRB1*03:14")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_140():
    result = parse("DRB1*03:140")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:140") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_141():
    result = parse("DRB1*03:141")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:141") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_142():
    result = parse("DRB1*03:142")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:142") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_143():
    result = parse("DRB1*03:143")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:143") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_144():
    result = parse("DRB1*03:144")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:144") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_145():
    result = parse("DRB1*03:145")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:145") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_146():
    result = parse("DRB1*03:146")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:146") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_147():
    result = parse("DRB1*03:147")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:147") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_148():
    result = parse("DRB1*03:148")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:148") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_149():
    result = parse("DRB1*03:149")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:149") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_150():
    result = parse("DRB1*03:150")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:150") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_151():
    result = parse("DRB1*03:151")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:151") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_152():
    result = parse("DRB1*03:152")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:152") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_153():
    result = parse("DRB1*03:153")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:153") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_154():
    result = parse("DRB1*03:154")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:154") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_155():
    result = parse("DRB1*03:155")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:155") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_156N():
    result = parse("DRB1*03:156N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:156N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:156N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_157():
    result = parse("DRB1*03:157")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:157") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_158():
    result = parse("DRB1*03:158")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:158") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_159():
    result = parse("DRB1*03:159")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:159") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_15_01():
    result = parse("DRB1*03:15:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:15:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:15:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_15_02():
    result = parse("DRB1*03:15:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:15:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:15:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_16():
    result = parse("DRB1*03:16")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_160():
    result = parse("DRB1*03:160")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:160") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_161():
    result = parse("DRB1*03:161")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:161") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_162():
    result = parse("DRB1*03:162")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:162") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_163():
    result = parse("DRB1*03:163")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:163") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_164():
    result = parse("DRB1*03:164")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:164") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_165():
    result = parse("DRB1*03:165")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:165") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_166():
    result = parse("DRB1*03:166")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:166") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_167():
    result = parse("DRB1*03:167")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:167") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_168():
    result = parse("DRB1*03:168")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:168") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_169():
    result = parse("DRB1*03:169")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:169") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_17():
    result = parse("DRB1*03:17")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_170():
    result = parse("DRB1*03:170")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:170") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_171():
    result = parse("DRB1*03:171")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:171") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_172():
    result = parse("DRB1*03:172")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:172") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_173():
    result = parse("DRB1*03:173")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:173") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_174N():
    result = parse("DRB1*03:174N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:174N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:174N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_18():
    result = parse("DRB1*03:18")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_19():
    result = parse("DRB1*03:19")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_20():
    result = parse("DRB1*03:20")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_21():
    result = parse("DRB1*03:21")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_22():
    result = parse("DRB1*03:22")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_23():
    result = parse("DRB1*03:23")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_24():
    result = parse("DRB1*03:24")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_25_01():
    result = parse("DRB1*03:25:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:25:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:25:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_25_02():
    result = parse("DRB1*03:25:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:25:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:25:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_26():
    result = parse("DRB1*03:26")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_27():
    result = parse("DRB1*03:27")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_28():
    result = parse("DRB1*03:28")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_29():
    result = parse("DRB1*03:29")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_30():
    result = parse("DRB1*03:30")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_31():
    result = parse("DRB1*03:31")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_32():
    result = parse("DRB1*03:32")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_33():
    result = parse("DRB1*03:33")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_34():
    result = parse("DRB1*03:34")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_35():
    result = parse("DRB1*03:35")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_36():
    result = parse("DRB1*03:36")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_37():
    result = parse("DRB1*03:37")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_38():
    result = parse("DRB1*03:38")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_39():
    result = parse("DRB1*03:39")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_40():
    result = parse("DRB1*03:40")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_41_01():
    result = parse("DRB1*03:41:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:41:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:41:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_41_02():
    result = parse("DRB1*03:41:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:41:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:41:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_42():
    result = parse("DRB1*03:42")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_43():
    result = parse("DRB1*03:43")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_44():
    result = parse("DRB1*03:44")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_45():
    result = parse("DRB1*03:45")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_46():
    result = parse("DRB1*03:46")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_47():
    result = parse("DRB1*03:47")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_48():
    result = parse("DRB1*03:48")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_49():
    result = parse("DRB1*03:49")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_50():
    result = parse("DRB1*03:50")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_51():
    result = parse("DRB1*03:51")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_52_01():
    result = parse("DRB1*03:52:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:52:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:52:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_52_02():
    result = parse("DRB1*03:52:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:52:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:52:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_53():
    result = parse("DRB1*03:53")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_54():
    result = parse("DRB1*03:54")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_55():
    result = parse("DRB1*03:55")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_56():
    result = parse("DRB1*03:56")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_57():
    result = parse("DRB1*03:57")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_58():
    result = parse("DRB1*03:58")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_59():
    result = parse("DRB1*03:59")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_60():
    result = parse("DRB1*03:60")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_61():
    result = parse("DRB1*03:61")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_62():
    result = parse("DRB1*03:62")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_63():
    result = parse("DRB1*03:63")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_64():
    result = parse("DRB1*03:64")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_65():
    result = parse("DRB1*03:65")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_66():
    result = parse("DRB1*03:66")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_67N():
    result = parse("DRB1*03:67N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:67N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:67N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_68N():
    result = parse("DRB1*03:68N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:68N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:68N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_69():
    result = parse("DRB1*03:69")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_70():
    result = parse("DRB1*03:70")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_71_01():
    result = parse("DRB1*03:71:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:71:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:71:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_71_02():
    result = parse("DRB1*03:71:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*03:71:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*03:71:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_72():
    result = parse("DRB1*03:72")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_73():
    result = parse("DRB1*03:73")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_74():
    result = parse("DRB1*03:74")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_75():
    result = parse("DRB1*03:75")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_76():
    result = parse("DRB1*03:76")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_77():
    result = parse("DRB1*03:77")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_78():
    result = parse("DRB1*03:78")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_79():
    result = parse("DRB1*03:79")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_80():
    result = parse("DRB1*03:80")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_81():
    result = parse("DRB1*03:81")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_82():
    result = parse("DRB1*03:82")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_83():
    result = parse("DRB1*03:83")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_84():
    result = parse("DRB1*03:84")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_85():
    result = parse("DRB1*03:85")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_86():
    result = parse("DRB1*03:86")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_87():
    result = parse("DRB1*03:87")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_88():
    result = parse("DRB1*03:88")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_89():
    result = parse("DRB1*03:89")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_90():
    result = parse("DRB1*03:90")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_91():
    result = parse("DRB1*03:91")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_92():
    result = parse("DRB1*03:92")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_93():
    result = parse("DRB1*03:93")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_94():
    result = parse("DRB1*03:94")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_95():
    result = parse("DRB1*03:95")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_96():
    result = parse("DRB1*03:96")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_97():
    result = parse("DRB1*03:97")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_98():
    result = parse("DRB1*03:98")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_03_99():
    result = parse("DRB1*03:99")
    assert result.__class__ is Allele, f'Expected parse("DRB1*03:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*03:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_01_01():
    result = parse("DRB1*04:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*04:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_01_02():
    result = parse("DRB1*04:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*04:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_01_03():
    result = parse("DRB1*04:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*04:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_02():
    result = parse("DRB1*04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_03():
    result = parse("DRB1*04:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_04():
    result = parse("DRB1*04:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_05():
    result = parse("DRB1*04:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_06():
    result = parse("DRB1*04:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_07():
    result = parse("DRB1*04:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_08():
    result = parse("DRB1*04:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_09():
    result = parse("DRB1*04:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_10():
    result = parse("DRB1*04:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_11():
    result = parse("DRB1*04:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_12():
    result = parse("DRB1*04:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_13():
    result = parse("DRB1*04:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_14():
    result = parse("DRB1*04:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_15():
    result = parse("DRB1*04:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_16():
    result = parse("DRB1*04:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_17():
    result = parse("DRB1*04:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_18():
    result = parse("DRB1*04:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_19():
    result = parse("DRB1*04:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_20():
    result = parse("DRB1*04:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_21():
    result = parse("DRB1*04:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_01_22():
    result = parse("DRB1*04:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_02_01():
    result = parse("DRB1*04:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_02_02():
    result = parse("DRB1*04:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_02_03():
    result = parse("DRB1*04:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_02_04():
    result = parse("DRB1*04:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_02_05():
    result = parse("DRB1*04:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_02_06():
    result = parse("DRB1*04:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_01_01():
    result = parse("DRB1*04:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*04:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_01_02():
    result = parse("DRB1*04:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*04:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_02():
    result = parse("DRB1*04:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_03():
    result = parse("DRB1*04:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_04():
    result = parse("DRB1*04:03:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_05():
    result = parse("DRB1*04:03:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_06():
    result = parse("DRB1*04:03:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_07():
    result = parse("DRB1*04:03:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_08():
    result = parse("DRB1*04:03:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:03:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_09():
    result = parse("DRB1*04:03:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:03:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_10():
    result = parse("DRB1*04:03:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:03:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_11():
    result = parse("DRB1*04:03:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:03:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_12():
    result = parse("DRB1*04:03:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:03:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_13():
    result = parse("DRB1*04:03:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:03:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_14():
    result = parse("DRB1*04:03:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:03:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_15():
    result = parse("DRB1*04:03:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:03:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_03_16():
    result = parse("DRB1*04:03:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:03:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:03:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_01():
    result = parse("DRB1*04:04:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_02():
    result = parse("DRB1*04:04:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_03():
    result = parse("DRB1*04:04:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_04():
    result = parse("DRB1*04:04:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_05():
    result = parse("DRB1*04:04:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_06():
    result = parse("DRB1*04:04:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_07():
    result = parse("DRB1*04:04:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_08():
    result = parse("DRB1*04:04:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_09():
    result = parse("DRB1*04:04:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_10():
    result = parse("DRB1*04:04:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_11():
    result = parse("DRB1*04:04:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_12():
    result = parse("DRB1*04:04:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_13():
    result = parse("DRB1*04:04:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_14():
    result = parse("DRB1*04:04:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_15():
    result = parse("DRB1*04:04:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_16():
    result = parse("DRB1*04:04:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_04_17():
    result = parse("DRB1*04:04:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:04:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:04:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_01_01():
    result = parse("DRB1*04:05:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*04:05:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_01_02():
    result = parse("DRB1*04:05:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*04:05:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_01_03():
    result = parse("DRB1*04:05:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*04:05:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_01_04():
    result = parse("DRB1*04:05:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*04:05:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_02():
    result = parse("DRB1*04:05:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_03():
    result = parse("DRB1*04:05:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_04():
    result = parse("DRB1*04:05:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_05():
    result = parse("DRB1*04:05:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_06():
    result = parse("DRB1*04:05:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_07():
    result = parse("DRB1*04:05:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_08():
    result = parse("DRB1*04:05:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_09():
    result = parse("DRB1*04:05:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_10():
    result = parse("DRB1*04:05:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_11():
    result = parse("DRB1*04:05:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_13():
    result = parse("DRB1*04:05:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_14():
    result = parse("DRB1*04:05:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_15():
    result = parse("DRB1*04:05:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_16():
    result = parse("DRB1*04:05:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_17():
    result = parse("DRB1*04:05:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_18():
    result = parse("DRB1*04:05:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_19():
    result = parse("DRB1*04:05:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_20():
    result = parse("DRB1*04:05:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_21():
    result = parse("DRB1*04:05:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_05_22():
    result = parse("DRB1*04:05:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:05:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:05:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_06_01():
    result = parse("DRB1*04:06:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:06:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_06_02():
    result = parse("DRB1*04:06:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:06:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_06_03():
    result = parse("DRB1*04:06:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:06:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:06:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_06_04():
    result = parse("DRB1*04:06:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:06:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:06:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_06_05():
    result = parse("DRB1*04:06:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:06:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:06:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_06_06():
    result = parse("DRB1*04:06:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:06:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:06:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_06_07():
    result = parse("DRB1*04:06:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:06:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:06:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_07_01_01():
    result = parse("DRB1*04:07:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:07:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*04:07:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_07_01_02():
    result = parse("DRB1*04:07:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:07:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*04:07:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_07_02():
    result = parse("DRB1*04:07:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:07:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_07_03():
    result = parse("DRB1*04:07:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:07:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:07:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_07_04():
    result = parse("DRB1*04:07:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:07:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:07:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_07_05():
    result = parse("DRB1*04:07:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:07:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:07:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_07_06():
    result = parse("DRB1*04:07:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:07:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:07:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_08_01():
    result = parse("DRB1*04:08:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:08:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:08:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_08_02():
    result = parse("DRB1*04:08:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:08:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:08:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_08_03():
    result = parse("DRB1*04:08:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:08:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:08:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_08_04():
    result = parse("DRB1*04:08:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:08:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:08:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_08_05():
    result = parse("DRB1*04:08:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:08:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:08:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_09():
    result = parse("DRB1*04:09")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_100():
    result = parse("DRB1*04:100")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_101():
    result = parse("DRB1*04:101")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_102():
    result = parse("DRB1*04:102")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_103():
    result = parse("DRB1*04:103")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_104():
    result = parse("DRB1*04:104")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_105_01():
    result = parse("DRB1*04:105:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:105:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:105:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_105_02():
    result = parse("DRB1*04:105:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:105:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:105:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_106():
    result = parse("DRB1*04:106")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_107():
    result = parse("DRB1*04:107")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_108():
    result = parse("DRB1*04:108")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_109():
    result = parse("DRB1*04:109")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_10_01():
    result = parse("DRB1*04:10:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:10:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:10:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_10_02():
    result = parse("DRB1*04:10:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:10:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:10:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_10_03():
    result = parse("DRB1*04:10:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:10:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:10:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_110():
    result = parse("DRB1*04:110")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_111():
    result = parse("DRB1*04:111")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_112():
    result = parse("DRB1*04:112")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_113():
    result = parse("DRB1*04:113")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_114():
    result = parse("DRB1*04:114")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_115():
    result = parse("DRB1*04:115")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:115") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_116():
    result = parse("DRB1*04:116")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_117():
    result = parse("DRB1*04:117")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_118():
    result = parse("DRB1*04:118")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:118") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_119N():
    result = parse("DRB1*04:119N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:119N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:119N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_11_01():
    result = parse("DRB1*04:11:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:11:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:11:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_11_02():
    result = parse("DRB1*04:11:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:11:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:11:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_11_03():
    result = parse("DRB1*04:11:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:11:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:11:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_11_04():
    result = parse("DRB1*04:11:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:11:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:11:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_11_05():
    result = parse("DRB1*04:11:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:11:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:11:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_11_06():
    result = parse("DRB1*04:11:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:11:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:11:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_12():
    result = parse("DRB1*04:12")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_120N():
    result = parse("DRB1*04:120N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:120N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:120N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_121():
    result = parse("DRB1*04:121")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:121") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_122():
    result = parse("DRB1*04:122")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:122") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_123():
    result = parse("DRB1*04:123")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:123") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_124():
    result = parse("DRB1*04:124")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:124") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_125():
    result = parse("DRB1*04:125")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:125") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_126():
    result = parse("DRB1*04:126")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:126") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_127():
    result = parse("DRB1*04:127")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:127") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_128():
    result = parse("DRB1*04:128")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:128") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_129():
    result = parse("DRB1*04:129")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:129") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_13():
    result = parse("DRB1*04:13")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_130_01():
    result = parse("DRB1*04:130:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:130:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:130:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_130_02():
    result = parse("DRB1*04:130:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:130:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:130:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_131_01():
    result = parse("DRB1*04:131:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:131:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:131:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_131_02():
    result = parse("DRB1*04:131:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:131:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:131:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_132():
    result = parse("DRB1*04:132")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:132") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_133():
    result = parse("DRB1*04:133")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:133") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_134():
    result = parse("DRB1*04:134")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:134") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_135():
    result = parse("DRB1*04:135")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:135") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_136():
    result = parse("DRB1*04:136")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:136") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_137():
    result = parse("DRB1*04:137")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:137") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_138():
    result = parse("DRB1*04:138")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:138") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_139():
    result = parse("DRB1*04:139")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:139") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_14():
    result = parse("DRB1*04:14")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_140():
    result = parse("DRB1*04:140")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:140") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_141():
    result = parse("DRB1*04:141")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:141") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_142N():
    result = parse("DRB1*04:142N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:142N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:142N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_143():
    result = parse("DRB1*04:143")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:143") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_144():
    result = parse("DRB1*04:144")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:144") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_145():
    result = parse("DRB1*04:145")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:145") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_146():
    result = parse("DRB1*04:146")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:146") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_147():
    result = parse("DRB1*04:147")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:147") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_148():
    result = parse("DRB1*04:148")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:148") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_149():
    result = parse("DRB1*04:149")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:149") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_15():
    result = parse("DRB1*04:15")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_150():
    result = parse("DRB1*04:150")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:150") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_151():
    result = parse("DRB1*04:151")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:151") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_152():
    result = parse("DRB1*04:152")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:152") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_153():
    result = parse("DRB1*04:153")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:153") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_154():
    result = parse("DRB1*04:154")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:154") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_155():
    result = parse("DRB1*04:155")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:155") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_156():
    result = parse("DRB1*04:156")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:156") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_157N():
    result = parse("DRB1*04:157N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:157N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:157N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_158N():
    result = parse("DRB1*04:158N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:158N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:158N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_159():
    result = parse("DRB1*04:159")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:159") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_16():
    result = parse("DRB1*04:16")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_160():
    result = parse("DRB1*04:160")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:160") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_161():
    result = parse("DRB1*04:161")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:161") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_162():
    result = parse("DRB1*04:162")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:162") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_163():
    result = parse("DRB1*04:163")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:163") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_164():
    result = parse("DRB1*04:164")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:164") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_165():
    result = parse("DRB1*04:165")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:165") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_166():
    result = parse("DRB1*04:166")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:166") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_167():
    result = parse("DRB1*04:167")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:167") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_168():
    result = parse("DRB1*04:168")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:168") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_169():
    result = parse("DRB1*04:169")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:169") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_170():
    result = parse("DRB1*04:170")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:170") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_171():
    result = parse("DRB1*04:171")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:171") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_172():
    result = parse("DRB1*04:172")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:172") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_173():
    result = parse("DRB1*04:173")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:173") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_174():
    result = parse("DRB1*04:174")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:174") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_175():
    result = parse("DRB1*04:175")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:175") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_176():
    result = parse("DRB1*04:176")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:176") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_177():
    result = parse("DRB1*04:177")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:177") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_178N():
    result = parse("DRB1*04:178N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:178N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:178N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_179():
    result = parse("DRB1*04:179")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:179") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_17_01():
    result = parse("DRB1*04:17:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:17:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:17:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_17_02():
    result = parse("DRB1*04:17:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:17:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:17:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_18():
    result = parse("DRB1*04:18")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_180():
    result = parse("DRB1*04:180")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:180") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_181():
    result = parse("DRB1*04:181")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:181") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_182():
    result = parse("DRB1*04:182")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:182") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_183():
    result = parse("DRB1*04:183")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:183") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_184():
    result = parse("DRB1*04:184")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:184") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_185():
    result = parse("DRB1*04:185")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:185") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_186N():
    result = parse("DRB1*04:186N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:186N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:186N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_187():
    result = parse("DRB1*04:187")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:187") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_188():
    result = parse("DRB1*04:188")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:188") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_189():
    result = parse("DRB1*04:189")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:189") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_19():
    result = parse("DRB1*04:19")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_190():
    result = parse("DRB1*04:190")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:190") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_191():
    result = parse("DRB1*04:191")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:191") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_192():
    result = parse("DRB1*04:192")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:192") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_193():
    result = parse("DRB1*04:193")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:193") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_194():
    result = parse("DRB1*04:194")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:194") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_195():
    result = parse("DRB1*04:195")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:195") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_196():
    result = parse("DRB1*04:196")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:196") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_197():
    result = parse("DRB1*04:197")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:197") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_198():
    result = parse("DRB1*04:198")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:198") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_199():
    result = parse("DRB1*04:199")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:199") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_20():
    result = parse("DRB1*04:20")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_200():
    result = parse("DRB1*04:200")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:200") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_201():
    result = parse("DRB1*04:201")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:201") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_202():
    result = parse("DRB1*04:202")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:202") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_203():
    result = parse("DRB1*04:203")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:203") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_204():
    result = parse("DRB1*04:204")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:204") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_205():
    result = parse("DRB1*04:205")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:205") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_206():
    result = parse("DRB1*04:206")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:206") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_207():
    result = parse("DRB1*04:207")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:207") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_208():
    result = parse("DRB1*04:208")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:208") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_209():
    result = parse("DRB1*04:209")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:209") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_21():
    result = parse("DRB1*04:21")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_210():
    result = parse("DRB1*04:210")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:210") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_211():
    result = parse("DRB1*04:211")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:211") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_212N():
    result = parse("DRB1*04:212N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:212N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:212N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_213():
    result = parse("DRB1*04:213")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:213") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_214N():
    result = parse("DRB1*04:214N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:214N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:214N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_215():
    result = parse("DRB1*04:215")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:215") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_216():
    result = parse("DRB1*04:216")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:216") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_217():
    result = parse("DRB1*04:217")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:217") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_218():
    result = parse("DRB1*04:218")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:218") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_219():
    result = parse("DRB1*04:219")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:219") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_22():
    result = parse("DRB1*04:22")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_220():
    result = parse("DRB1*04:220")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:220") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_221():
    result = parse("DRB1*04:221")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:221") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_222():
    result = parse("DRB1*04:222")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:222") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_223():
    result = parse("DRB1*04:223")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:223") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_224():
    result = parse("DRB1*04:224")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:224") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_225():
    result = parse("DRB1*04:225")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:225") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_226_01():
    result = parse("DRB1*04:226:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:226:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:226:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_226_02():
    result = parse("DRB1*04:226:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:226:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:226:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_227():
    result = parse("DRB1*04:227")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:227") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_228():
    result = parse("DRB1*04:228")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:228") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_229():
    result = parse("DRB1*04:229")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:229") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_23():
    result = parse("DRB1*04:23")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_230():
    result = parse("DRB1*04:230")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:230") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_231():
    result = parse("DRB1*04:231")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:231") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_232():
    result = parse("DRB1*04:232")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:232") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_233():
    result = parse("DRB1*04:233")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:233") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_234():
    result = parse("DRB1*04:234")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:234") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_235():
    result = parse("DRB1*04:235")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:235") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_236():
    result = parse("DRB1*04:236")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:236") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_237():
    result = parse("DRB1*04:237")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:237") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_238():
    result = parse("DRB1*04:238")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:238") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_239():
    result = parse("DRB1*04:239")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:239") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_24():
    result = parse("DRB1*04:24")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_240():
    result = parse("DRB1*04:240")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:240") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_241():
    result = parse("DRB1*04:241")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:241") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_242():
    result = parse("DRB1*04:242")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:242") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_243():
    result = parse("DRB1*04:243")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:243") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_244():
    result = parse("DRB1*04:244")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:244") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_245():
    result = parse("DRB1*04:245")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:245") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_246():
    result = parse("DRB1*04:246")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:246") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_247N():
    result = parse("DRB1*04:247N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:247N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:247N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_248():
    result = parse("DRB1*04:248")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:248") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_249():
    result = parse("DRB1*04:249")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:249") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_25():
    result = parse("DRB1*04:25")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_250():
    result = parse("DRB1*04:250")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:250") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_251():
    result = parse("DRB1*04:251")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:251") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_252():
    result = parse("DRB1*04:252")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:252") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_253():
    result = parse("DRB1*04:253")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:253") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_254():
    result = parse("DRB1*04:254")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:254") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_255():
    result = parse("DRB1*04:255")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:255") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_256():
    result = parse("DRB1*04:256")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:256") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_257():
    result = parse("DRB1*04:257")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:257") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_258():
    result = parse("DRB1*04:258")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:258") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_259():
    result = parse("DRB1*04:259")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:259") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_26():
    result = parse("DRB1*04:26")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_260():
    result = parse("DRB1*04:260")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:260") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_261():
    result = parse("DRB1*04:261")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:261") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_262():
    result = parse("DRB1*04:262")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:262") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_263():
    result = parse("DRB1*04:263")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:263") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_264N():
    result = parse("DRB1*04:264N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:264N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:264N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_265():
    result = parse("DRB1*04:265")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:265") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_266N():
    result = parse("DRB1*04:266N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:266N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:266N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_267N():
    result = parse("DRB1*04:267N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:267N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:267N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_268():
    result = parse("DRB1*04:268")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:268") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_269():
    result = parse("DRB1*04:269")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:269") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_27():
    result = parse("DRB1*04:27")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_270():
    result = parse("DRB1*04:270")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:270") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_271():
    result = parse("DRB1*04:271")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:271") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_272():
    result = parse("DRB1*04:272")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:272") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_273():
    result = parse("DRB1*04:273")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:273") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_274():
    result = parse("DRB1*04:274")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:274") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_275():
    result = parse("DRB1*04:275")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:275") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_276():
    result = parse("DRB1*04:276")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:276") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_277():
    result = parse("DRB1*04:277")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:277") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_278():
    result = parse("DRB1*04:278")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:278") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_279():
    result = parse("DRB1*04:279")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:279") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_28():
    result = parse("DRB1*04:28")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_280N():
    result = parse("DRB1*04:280N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:280N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:280N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_281():
    result = parse("DRB1*04:281")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:281") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_282():
    result = parse("DRB1*04:282")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:282") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_283():
    result = parse("DRB1*04:283")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:283") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_284():
    result = parse("DRB1*04:284")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:284") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_285():
    result = parse("DRB1*04:285")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:285") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_286N():
    result = parse("DRB1*04:286N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:286N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:286N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_287():
    result = parse("DRB1*04:287")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:287") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:287") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_288():
    result = parse("DRB1*04:288")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:288") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_289():
    result = parse("DRB1*04:289")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:289") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_29():
    result = parse("DRB1*04:29")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_290():
    result = parse("DRB1*04:290")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:290") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_291():
    result = parse("DRB1*04:291")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:291") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_292():
    result = parse("DRB1*04:292")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:292") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_293():
    result = parse("DRB1*04:293")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:293") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_294():
    result = parse("DRB1*04:294")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:294") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_295():
    result = parse("DRB1*04:295")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:295") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_296():
    result = parse("DRB1*04:296")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:296") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_297():
    result = parse("DRB1*04:297")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:297") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_298():
    result = parse("DRB1*04:298")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:298") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_299N():
    result = parse("DRB1*04:299N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:299N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:299N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_30():
    result = parse("DRB1*04:30")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_300N():
    result = parse("DRB1*04:300N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:300N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:300N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_301():
    result = parse("DRB1*04:301")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:301") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_302():
    result = parse("DRB1*04:302")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:302") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_303():
    result = parse("DRB1*04:303")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:303") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:303") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_304():
    result = parse("DRB1*04:304")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:304") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:304") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_305():
    result = parse("DRB1*04:305")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:305") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_31():
    result = parse("DRB1*04:31")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_32():
    result = parse("DRB1*04:32")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_33():
    result = parse("DRB1*04:33")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_34():
    result = parse("DRB1*04:34")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_35():
    result = parse("DRB1*04:35")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_36():
    result = parse("DRB1*04:36")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_37():
    result = parse("DRB1*04:37")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_38():
    result = parse("DRB1*04:38")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_39():
    result = parse("DRB1*04:39")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_40():
    result = parse("DRB1*04:40")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_41():
    result = parse("DRB1*04:41")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_42():
    result = parse("DRB1*04:42")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_43():
    result = parse("DRB1*04:43")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_44_01():
    result = parse("DRB1*04:44:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:44:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:44:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_44_02():
    result = parse("DRB1*04:44:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:44:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:44:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_45():
    result = parse("DRB1*04:45")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_46():
    result = parse("DRB1*04:46")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_47():
    result = parse("DRB1*04:47")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_48():
    result = parse("DRB1*04:48")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_49():
    result = parse("DRB1*04:49")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_50():
    result = parse("DRB1*04:50")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_51():
    result = parse("DRB1*04:51")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_52():
    result = parse("DRB1*04:52")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_53_01():
    result = parse("DRB1*04:53:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:53:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:53:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_53_02():
    result = parse("DRB1*04:53:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:53:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:53:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_54():
    result = parse("DRB1*04:54")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_55():
    result = parse("DRB1*04:55")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_56_01():
    result = parse("DRB1*04:56:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:56:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:56:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_56_02():
    result = parse("DRB1*04:56:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:56:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:56:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_57():
    result = parse("DRB1*04:57")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_58():
    result = parse("DRB1*04:58")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_59():
    result = parse("DRB1*04:59")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_60():
    result = parse("DRB1*04:60")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_61():
    result = parse("DRB1*04:61")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_62():
    result = parse("DRB1*04:62")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_63():
    result = parse("DRB1*04:63")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_64():
    result = parse("DRB1*04:64")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_65():
    result = parse("DRB1*04:65")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_66():
    result = parse("DRB1*04:66")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_67():
    result = parse("DRB1*04:67")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_68():
    result = parse("DRB1*04:68")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_69():
    result = parse("DRB1*04:69")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_70():
    result = parse("DRB1*04:70")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_71():
    result = parse("DRB1*04:71")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_72_01():
    result = parse("DRB1*04:72:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:72:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:72:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_72_02():
    result = parse("DRB1*04:72:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:72:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:72:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_73_01():
    result = parse("DRB1*04:73:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:73:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:73:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_73_02():
    result = parse("DRB1*04:73:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:73:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:73:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_74():
    result = parse("DRB1*04:74")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_75():
    result = parse("DRB1*04:75")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_76():
    result = parse("DRB1*04:76")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_77():
    result = parse("DRB1*04:77")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_78():
    result = parse("DRB1*04:78")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_79():
    result = parse("DRB1*04:79")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_80():
    result = parse("DRB1*04:80")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_81N():
    result = parse("DRB1*04:81N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:81N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:81N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_82():
    result = parse("DRB1*04:82")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_83():
    result = parse("DRB1*04:83")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_84():
    result = parse("DRB1*04:84")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_85():
    result = parse("DRB1*04:85")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_86():
    result = parse("DRB1*04:86")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_87():
    result = parse("DRB1*04:87")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_88():
    result = parse("DRB1*04:88")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_89():
    result = parse("DRB1*04:89")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_90():
    result = parse("DRB1*04:90")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_91():
    result = parse("DRB1*04:91")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_92():
    result = parse("DRB1*04:92")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_93():
    result = parse("DRB1*04:93")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_94_01N():
    result = parse("DRB1*04:94:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:94:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:94:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_95_01():
    result = parse("DRB1*04:95:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:95:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:95:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_95_02():
    result = parse("DRB1*04:95:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:95:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:95:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_96():
    result = parse("DRB1*04:96")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_97():
    result = parse("DRB1*04:97")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_98_01():
    result = parse("DRB1*04:98:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:98:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:98:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_98_02():
    result = parse("DRB1*04:98:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*04:98:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*04:98:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_04_99():
    result = parse("DRB1*04:99")
    assert result.__class__ is Allele, f'Expected parse("DRB1*04:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*04:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_01_01():
    result = parse("DRB1*07:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*07:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_01_02():
    result = parse("DRB1*07:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*07:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_01_03():
    result = parse("DRB1*07:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*07:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_01_04():
    result = parse("DRB1*07:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*07:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_02():
    result = parse("DRB1*07:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_03():
    result = parse("DRB1*07:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_04():
    result = parse("DRB1*07:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_05():
    result = parse("DRB1*07:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_06():
    result = parse("DRB1*07:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_07():
    result = parse("DRB1*07:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_08():
    result = parse("DRB1*07:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_09():
    result = parse("DRB1*07:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_10():
    result = parse("DRB1*07:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_11():
    result = parse("DRB1*07:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_12():
    result = parse("DRB1*07:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_13():
    result = parse("DRB1*07:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_14():
    result = parse("DRB1*07:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_15():
    result = parse("DRB1*07:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_16():
    result = parse("DRB1*07:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_17():
    result = parse("DRB1*07:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_18():
    result = parse("DRB1*07:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_19():
    result = parse("DRB1*07:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_20():
    result = parse("DRB1*07:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_21():
    result = parse("DRB1*07:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_22():
    result = parse("DRB1*07:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_01_23():
    result = parse("DRB1*07:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_03():
    result = parse("DRB1*07:03")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_04():
    result = parse("DRB1*07:04")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_05():
    result = parse("DRB1*07:05")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_06():
    result = parse("DRB1*07:06")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_07():
    result = parse("DRB1*07:07")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_08():
    result = parse("DRB1*07:08")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_09():
    result = parse("DRB1*07:09")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_100():
    result = parse("DRB1*07:100")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_101N():
    result = parse("DRB1*07:101N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:101N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:101N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_102():
    result = parse("DRB1*07:102")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_103():
    result = parse("DRB1*07:103")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_104():
    result = parse("DRB1*07:104")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_105():
    result = parse("DRB1*07:105")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_106():
    result = parse("DRB1*07:106")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_107():
    result = parse("DRB1*07:107")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_108():
    result = parse("DRB1*07:108")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_109():
    result = parse("DRB1*07:109")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_10N():
    result = parse("DRB1*07:10N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:10N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:10N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_11():
    result = parse("DRB1*07:11")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_110():
    result = parse("DRB1*07:110")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_111():
    result = parse("DRB1*07:111")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_112():
    result = parse("DRB1*07:112")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_113():
    result = parse("DRB1*07:113")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_114():
    result = parse("DRB1*07:114")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_12():
    result = parse("DRB1*07:12")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_13():
    result = parse("DRB1*07:13")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_14():
    result = parse("DRB1*07:14")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_15():
    result = parse("DRB1*07:15")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_16():
    result = parse("DRB1*07:16")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_17():
    result = parse("DRB1*07:17")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_18():
    result = parse("DRB1*07:18")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_19():
    result = parse("DRB1*07:19")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_20():
    result = parse("DRB1*07:20")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_21():
    result = parse("DRB1*07:21")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_22():
    result = parse("DRB1*07:22")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_23():
    result = parse("DRB1*07:23")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_24():
    result = parse("DRB1*07:24")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_25():
    result = parse("DRB1*07:25")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_26N():
    result = parse("DRB1*07:26N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:26N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:26N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_27():
    result = parse("DRB1*07:27")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_28():
    result = parse("DRB1*07:28")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_29():
    result = parse("DRB1*07:29")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_30():
    result = parse("DRB1*07:30")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_31():
    result = parse("DRB1*07:31")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_32():
    result = parse("DRB1*07:32")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_33():
    result = parse("DRB1*07:33")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_34_01():
    result = parse("DRB1*07:34:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:34:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:34:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_34_02():
    result = parse("DRB1*07:34:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:34:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*07:34:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_35():
    result = parse("DRB1*07:35")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_36():
    result = parse("DRB1*07:36")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_37():
    result = parse("DRB1*07:37")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_38():
    result = parse("DRB1*07:38")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_39():
    result = parse("DRB1*07:39")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_40():
    result = parse("DRB1*07:40")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_41():
    result = parse("DRB1*07:41")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_42():
    result = parse("DRB1*07:42")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_43():
    result = parse("DRB1*07:43")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_44():
    result = parse("DRB1*07:44")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_45():
    result = parse("DRB1*07:45")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_46():
    result = parse("DRB1*07:46")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_47():
    result = parse("DRB1*07:47")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_48():
    result = parse("DRB1*07:48")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_49():
    result = parse("DRB1*07:49")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_50():
    result = parse("DRB1*07:50")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_51():
    result = parse("DRB1*07:51")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_52():
    result = parse("DRB1*07:52")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_53():
    result = parse("DRB1*07:53")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_54():
    result = parse("DRB1*07:54")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_55():
    result = parse("DRB1*07:55")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_56():
    result = parse("DRB1*07:56")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_57():
    result = parse("DRB1*07:57")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_58N():
    result = parse("DRB1*07:58N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:58N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:58N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_59():
    result = parse("DRB1*07:59")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_60():
    result = parse("DRB1*07:60")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_61():
    result = parse("DRB1*07:61")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_62():
    result = parse("DRB1*07:62")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_63():
    result = parse("DRB1*07:63")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_64():
    result = parse("DRB1*07:64")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_65():
    result = parse("DRB1*07:65")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_66():
    result = parse("DRB1*07:66")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_67():
    result = parse("DRB1*07:67")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_68N():
    result = parse("DRB1*07:68N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:68N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:68N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_69():
    result = parse("DRB1*07:69")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_70():
    result = parse("DRB1*07:70")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_71():
    result = parse("DRB1*07:71")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_72():
    result = parse("DRB1*07:72")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_73():
    result = parse("DRB1*07:73")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_74():
    result = parse("DRB1*07:74")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_75():
    result = parse("DRB1*07:75")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_76():
    result = parse("DRB1*07:76")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_77():
    result = parse("DRB1*07:77")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_78():
    result = parse("DRB1*07:78")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_79():
    result = parse("DRB1*07:79")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_80():
    result = parse("DRB1*07:80")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_81():
    result = parse("DRB1*07:81")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_82():
    result = parse("DRB1*07:82")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_83():
    result = parse("DRB1*07:83")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_84():
    result = parse("DRB1*07:84")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_85():
    result = parse("DRB1*07:85")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_86():
    result = parse("DRB1*07:86")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_87N():
    result = parse("DRB1*07:87N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*07:87N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:87N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_88():
    result = parse("DRB1*07:88")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_89():
    result = parse("DRB1*07:89")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_90():
    result = parse("DRB1*07:90")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_91():
    result = parse("DRB1*07:91")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_92():
    result = parse("DRB1*07:92")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_93():
    result = parse("DRB1*07:93")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_94():
    result = parse("DRB1*07:94")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_95():
    result = parse("DRB1*07:95")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_96():
    result = parse("DRB1*07:96")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_97():
    result = parse("DRB1*07:97")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_98():
    result = parse("DRB1*07:98")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_07_99():
    result = parse("DRB1*07:99")
    assert result.__class__ is Allele, f'Expected parse("DRB1*07:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*07:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_01_01():
    result = parse("DRB1*08:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_01_02():
    result = parse("DRB1*08:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_01_04():
    result = parse("DRB1*08:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_01_05():
    result = parse("DRB1*08:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_01_06():
    result = parse("DRB1*08:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_01_07():
    result = parse("DRB1*08:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_02_01_01():
    result = parse("DRB1*08:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*08:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_02_01_02():
    result = parse("DRB1*08:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*08:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_02_02():
    result = parse("DRB1*08:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_02_03():
    result = parse("DRB1*08:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_02_04():
    result = parse("DRB1*08:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_03_02_01():
    result = parse("DRB1*08:03:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:03:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*08:03:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_03_02_02():
    result = parse("DRB1*08:03:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:03:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*08:03:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_03_02_03():
    result = parse("DRB1*08:03:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:03:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*08:03:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_03_03():
    result = parse("DRB1*08:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_03_04():
    result = parse("DRB1*08:03:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:03:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_03_05():
    result = parse("DRB1*08:03:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:03:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_03_06():
    result = parse("DRB1*08:03:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:03:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_03_07():
    result = parse("DRB1*08:03:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:03:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_03_08():
    result = parse("DRB1*08:03:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:03:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:03:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_03_09():
    result = parse("DRB1*08:03:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:03:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:03:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_03_10():
    result = parse("DRB1*08:03:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:03:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:03:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_03_11():
    result = parse("DRB1*08:03:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:03:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:03:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_04_01():
    result = parse("DRB1*08:04:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:04:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_04_02():
    result = parse("DRB1*08:04:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:04:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_04_03():
    result = parse("DRB1*08:04:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:04:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_04_04():
    result = parse("DRB1*08:04:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:04:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:04:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_04_05():
    result = parse("DRB1*08:04:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:04:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:04:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_04_06():
    result = parse("DRB1*08:04:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:04:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:04:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_04_07():
    result = parse("DRB1*08:04:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:04:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:04:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_05():
    result = parse("DRB1*08:05")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_06():
    result = parse("DRB1*08:06")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_07():
    result = parse("DRB1*08:07")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_08():
    result = parse("DRB1*08:08")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_09_01():
    result = parse("DRB1*08:09:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:09:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:09:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_09_02():
    result = parse("DRB1*08:09:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:09:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:09:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_10():
    result = parse("DRB1*08:10")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_100():
    result = parse("DRB1*08:100")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_101():
    result = parse("DRB1*08:101")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_102():
    result = parse("DRB1*08:102")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_103():
    result = parse("DRB1*08:103")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_11():
    result = parse("DRB1*08:11")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_12():
    result = parse("DRB1*08:12")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_13():
    result = parse("DRB1*08:13")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_14():
    result = parse("DRB1*08:14")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_15():
    result = parse("DRB1*08:15")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_16():
    result = parse("DRB1*08:16")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_17():
    result = parse("DRB1*08:17")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_18():
    result = parse("DRB1*08:18")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_19():
    result = parse("DRB1*08:19")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_20():
    result = parse("DRB1*08:20")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_21():
    result = parse("DRB1*08:21")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_22():
    result = parse("DRB1*08:22")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_23():
    result = parse("DRB1*08:23")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_24_01():
    result = parse("DRB1*08:24:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:24:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:24:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_24_02():
    result = parse("DRB1*08:24:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:24:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:24:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_25():
    result = parse("DRB1*08:25")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_26():
    result = parse("DRB1*08:26")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_27():
    result = parse("DRB1*08:27")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_28():
    result = parse("DRB1*08:28")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_29():
    result = parse("DRB1*08:29")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_30_01():
    result = parse("DRB1*08:30:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:30:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:30:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_30_02():
    result = parse("DRB1*08:30:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:30:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:30:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_30_03():
    result = parse("DRB1*08:30:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:30:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:30:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_31():
    result = parse("DRB1*08:31")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_32():
    result = parse("DRB1*08:32")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_33():
    result = parse("DRB1*08:33")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_34():
    result = parse("DRB1*08:34")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_35():
    result = parse("DRB1*08:35")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_36_01():
    result = parse("DRB1*08:36:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:36:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:36:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_36_02():
    result = parse("DRB1*08:36:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:36:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:36:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_37():
    result = parse("DRB1*08:37")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_38():
    result = parse("DRB1*08:38")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_39():
    result = parse("DRB1*08:39")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_40():
    result = parse("DRB1*08:40")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_41():
    result = parse("DRB1*08:41")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_42():
    result = parse("DRB1*08:42")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_43():
    result = parse("DRB1*08:43")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_44():
    result = parse("DRB1*08:44")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_45_01():
    result = parse("DRB1*08:45:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:45:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:45:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_45_02():
    result = parse("DRB1*08:45:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:45:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:45:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_46():
    result = parse("DRB1*08:46")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_47():
    result = parse("DRB1*08:47")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_48():
    result = parse("DRB1*08:48")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_49():
    result = parse("DRB1*08:49")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_50():
    result = parse("DRB1*08:50")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_51():
    result = parse("DRB1*08:51")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_52():
    result = parse("DRB1*08:52")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_53():
    result = parse("DRB1*08:53")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_54():
    result = parse("DRB1*08:54")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_55():
    result = parse("DRB1*08:55")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_56():
    result = parse("DRB1*08:56")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_57():
    result = parse("DRB1*08:57")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_58():
    result = parse("DRB1*08:58")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_59():
    result = parse("DRB1*08:59")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_60N():
    result = parse("DRB1*08:60N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:60N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:60N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_61():
    result = parse("DRB1*08:61")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_62():
    result = parse("DRB1*08:62")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_63():
    result = parse("DRB1*08:63")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_64():
    result = parse("DRB1*08:64")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_65():
    result = parse("DRB1*08:65")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_66():
    result = parse("DRB1*08:66")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_67():
    result = parse("DRB1*08:67")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_68_01():
    result = parse("DRB1*08:68:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:68:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:68:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_68_02():
    result = parse("DRB1*08:68:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:68:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*08:68:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_69():
    result = parse("DRB1*08:69")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_70():
    result = parse("DRB1*08:70")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_71():
    result = parse("DRB1*08:71")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_72():
    result = parse("DRB1*08:72")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_73():
    result = parse("DRB1*08:73")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_74():
    result = parse("DRB1*08:74")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_75():
    result = parse("DRB1*08:75")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_76():
    result = parse("DRB1*08:76")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_77():
    result = parse("DRB1*08:77")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_78N():
    result = parse("DRB1*08:78N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:78N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:78N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_79():
    result = parse("DRB1*08:79")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_80():
    result = parse("DRB1*08:80")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_81():
    result = parse("DRB1*08:81")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_82():
    result = parse("DRB1*08:82")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_83():
    result = parse("DRB1*08:83")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_84():
    result = parse("DRB1*08:84")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_85():
    result = parse("DRB1*08:85")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_86():
    result = parse("DRB1*08:86")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_87():
    result = parse("DRB1*08:87")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_88():
    result = parse("DRB1*08:88")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_89N():
    result = parse("DRB1*08:89N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*08:89N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:89N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_90():
    result = parse("DRB1*08:90")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_91():
    result = parse("DRB1*08:91")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_92():
    result = parse("DRB1*08:92")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_93():
    result = parse("DRB1*08:93")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_94():
    result = parse("DRB1*08:94")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_95():
    result = parse("DRB1*08:95")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_96():
    result = parse("DRB1*08:96")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_97():
    result = parse("DRB1*08:97")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_98():
    result = parse("DRB1*08:98")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_08_99():
    result = parse("DRB1*08:99")
    assert result.__class__ is Allele, f'Expected parse("DRB1*08:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*08:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_01_02_01():
    result = parse("DRB1*09:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*09:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*09:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_01_02_02():
    result = parse("DRB1*09:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*09:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*09:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_01_02_03():
    result = parse("DRB1*09:01:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*09:01:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*09:01:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_01_02_04():
    result = parse("DRB1*09:01:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*09:01:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*09:01:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_01_03():
    result = parse("DRB1*09:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*09:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*09:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_01_04():
    result = parse("DRB1*09:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*09:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*09:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_01_05():
    result = parse("DRB1*09:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*09:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*09:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_01_06():
    result = parse("DRB1*09:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*09:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*09:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_01_07():
    result = parse("DRB1*09:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*09:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*09:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_01_08():
    result = parse("DRB1*09:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*09:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*09:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_01_09():
    result = parse("DRB1*09:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*09:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*09:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_01_10():
    result = parse("DRB1*09:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*09:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*09:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_01_11():
    result = parse("DRB1*09:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*09:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*09:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_02_01():
    result = parse("DRB1*09:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*09:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*09:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_02_02():
    result = parse("DRB1*09:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*09:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*09:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_03():
    result = parse("DRB1*09:03")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_04():
    result = parse("DRB1*09:04")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_05():
    result = parse("DRB1*09:05")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_06():
    result = parse("DRB1*09:06")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_07():
    result = parse("DRB1*09:07")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_08():
    result = parse("DRB1*09:08")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_09():
    result = parse("DRB1*09:09")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_10():
    result = parse("DRB1*09:10")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_11():
    result = parse("DRB1*09:11")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_12():
    result = parse("DRB1*09:12")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_13():
    result = parse("DRB1*09:13")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_14():
    result = parse("DRB1*09:14")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_15():
    result = parse("DRB1*09:15")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_16():
    result = parse("DRB1*09:16")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_17():
    result = parse("DRB1*09:17")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_18():
    result = parse("DRB1*09:18")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_19():
    result = parse("DRB1*09:19")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_20():
    result = parse("DRB1*09:20")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_21():
    result = parse("DRB1*09:21")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_22():
    result = parse("DRB1*09:22")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_23():
    result = parse("DRB1*09:23")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_24():
    result = parse("DRB1*09:24")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_25():
    result = parse("DRB1*09:25")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_26():
    result = parse("DRB1*09:26")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_27():
    result = parse("DRB1*09:27")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_28():
    result = parse("DRB1*09:28")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_29():
    result = parse("DRB1*09:29")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_30():
    result = parse("DRB1*09:30")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_31():
    result = parse("DRB1*09:31")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_32():
    result = parse("DRB1*09:32")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_33():
    result = parse("DRB1*09:33")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_34():
    result = parse("DRB1*09:34")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_35():
    result = parse("DRB1*09:35")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_36():
    result = parse("DRB1*09:36")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_37N():
    result = parse("DRB1*09:37N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*09:37N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:37N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_38():
    result = parse("DRB1*09:38")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_39():
    result = parse("DRB1*09:39")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_40():
    result = parse("DRB1*09:40")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_41():
    result = parse("DRB1*09:41")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_42():
    result = parse("DRB1*09:42")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_43():
    result = parse("DRB1*09:43")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_09_44():
    result = parse("DRB1*09:44")
    assert result.__class__ is Allele, f'Expected parse("DRB1*09:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*09:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_01_01():
    result = parse("DRB1*10:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*10:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_01_02():
    result = parse("DRB1*10:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*10:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_01_03():
    result = parse("DRB1*10:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*10:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_02():
    result = parse("DRB1*10:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*10:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_03():
    result = parse("DRB1*10:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*10:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_04():
    result = parse("DRB1*10:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*10:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_05():
    result = parse("DRB1*10:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*10:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_06():
    result = parse("DRB1*10:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*10:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_07():
    result = parse("DRB1*10:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*10:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_08():
    result = parse("DRB1*10:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*10:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_09():
    result = parse("DRB1*10:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*10:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_10():
    result = parse("DRB1*10:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*10:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_11():
    result = parse("DRB1*10:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*10:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_12():
    result = parse("DRB1*10:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*10:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_13():
    result = parse("DRB1*10:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*10:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_14():
    result = parse("DRB1*10:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*10:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_01_15():
    result = parse("DRB1*10:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*10:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_02():
    result = parse("DRB1*10:02")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_03():
    result = parse("DRB1*10:03")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_04():
    result = parse("DRB1*10:04")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_05():
    result = parse("DRB1*10:05")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_06():
    result = parse("DRB1*10:06")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_07():
    result = parse("DRB1*10:07")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_08():
    result = parse("DRB1*10:08")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_09():
    result = parse("DRB1*10:09")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_10():
    result = parse("DRB1*10:10")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_11():
    result = parse("DRB1*10:11")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_12():
    result = parse("DRB1*10:12")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_13():
    result = parse("DRB1*10:13")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_14():
    result = parse("DRB1*10:14")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_15():
    result = parse("DRB1*10:15")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_16():
    result = parse("DRB1*10:16")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_17():
    result = parse("DRB1*10:17")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_18():
    result = parse("DRB1*10:18")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_19():
    result = parse("DRB1*10:19")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_20():
    result = parse("DRB1*10:20")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_21():
    result = parse("DRB1*10:21")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_22():
    result = parse("DRB1*10:22")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_23():
    result = parse("DRB1*10:23")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_24():
    result = parse("DRB1*10:24")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_25():
    result = parse("DRB1*10:25")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_26():
    result = parse("DRB1*10:26")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_27():
    result = parse("DRB1*10:27")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_28():
    result = parse("DRB1*10:28")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_29():
    result = parse("DRB1*10:29")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_30():
    result = parse("DRB1*10:30")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_31():
    result = parse("DRB1*10:31")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_32():
    result = parse("DRB1*10:32")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_33():
    result = parse("DRB1*10:33")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_34():
    result = parse("DRB1*10:34")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_35():
    result = parse("DRB1*10:35")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_36():
    result = parse("DRB1*10:36")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_37():
    result = parse("DRB1*10:37")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_38Q():
    result = parse("DRB1*10:38Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*10:38Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:38Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_10_39():
    result = parse("DRB1*10:39")
    assert result.__class__ is Allele, f'Expected parse("DRB1*10:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*10:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_01_01():
    result = parse("DRB1*11:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*11:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_01_02():
    result = parse("DRB1*11:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*11:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_01_03():
    result = parse("DRB1*11:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*11:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_01_04():
    result = parse("DRB1*11:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*11:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_02():
    result = parse("DRB1*11:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_03():
    result = parse("DRB1*11:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_04():
    result = parse("DRB1*11:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_05():
    result = parse("DRB1*11:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_06():
    result = parse("DRB1*11:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_07():
    result = parse("DRB1*11:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_08():
    result = parse("DRB1*11:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_09():
    result = parse("DRB1*11:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_10():
    result = parse("DRB1*11:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_11():
    result = parse("DRB1*11:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_12():
    result = parse("DRB1*11:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_13():
    result = parse("DRB1*11:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_14():
    result = parse("DRB1*11:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_15():
    result = parse("DRB1*11:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_16():
    result = parse("DRB1*11:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_17():
    result = parse("DRB1*11:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_18():
    result = parse("DRB1*11:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_19():
    result = parse("DRB1*11:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_20():
    result = parse("DRB1*11:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_21():
    result = parse("DRB1*11:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_22():
    result = parse("DRB1*11:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_23():
    result = parse("DRB1*11:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_24():
    result = parse("DRB1*11:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_25():
    result = parse("DRB1*11:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_26():
    result = parse("DRB1*11:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_27():
    result = parse("DRB1*11:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_28():
    result = parse("DRB1*11:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_29():
    result = parse("DRB1*11:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_30():
    result = parse("DRB1*11:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_31():
    result = parse("DRB1*11:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_32():
    result = parse("DRB1*11:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_33():
    result = parse("DRB1*11:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_34():
    result = parse("DRB1*11:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_35():
    result = parse("DRB1*11:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_36():
    result = parse("DRB1*11:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_37():
    result = parse("DRB1*11:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_38():
    result = parse("DRB1*11:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_39():
    result = parse("DRB1*11:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_01_40():
    result = parse("DRB1*11:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_02_01_01():
    result = parse("DRB1*11:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*11:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_02_01_02():
    result = parse("DRB1*11:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*11:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_02_02():
    result = parse("DRB1*11:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_02_03():
    result = parse("DRB1*11:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_02_04():
    result = parse("DRB1*11:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_02_05():
    result = parse("DRB1*11:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_03_01():
    result = parse("DRB1*11:03:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:03:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:03:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_03_02():
    result = parse("DRB1*11:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_03_03():
    result = parse("DRB1*11:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_03_04():
    result = parse("DRB1*11:03:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:03:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_01():
    result = parse("DRB1*11:04:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_02():
    result = parse("DRB1*11:04:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_03():
    result = parse("DRB1*11:04:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_04():
    result = parse("DRB1*11:04:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_05():
    result = parse("DRB1*11:04:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_06():
    result = parse("DRB1*11:04:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_07():
    result = parse("DRB1*11:04:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_08():
    result = parse("DRB1*11:04:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_09():
    result = parse("DRB1*11:04:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_10():
    result = parse("DRB1*11:04:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_11():
    result = parse("DRB1*11:04:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_12():
    result = parse("DRB1*11:04:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_13():
    result = parse("DRB1*11:04:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_14():
    result = parse("DRB1*11:04:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_15():
    result = parse("DRB1*11:04:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_16():
    result = parse("DRB1*11:04:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_17():
    result = parse("DRB1*11:04:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_18():
    result = parse("DRB1*11:04:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_19():
    result = parse("DRB1*11:04:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_20():
    result = parse("DRB1*11:04:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_04_21():
    result = parse("DRB1*11:04:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:04:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:04:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_05():
    result = parse("DRB1*11:05")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_06_01():
    result = parse("DRB1*11:06:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:06:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_06_02():
    result = parse("DRB1*11:06:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:06:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_06_03():
    result = parse("DRB1*11:06:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:06:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:06:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_07_01():
    result = parse("DRB1*11:07:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:07:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_07_02():
    result = parse("DRB1*11:07:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:07:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_08_01():
    result = parse("DRB1*11:08:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:08:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:08:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_08_02():
    result = parse("DRB1*11:08:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:08:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:08:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_08_03():
    result = parse("DRB1*11:08:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:08:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:08:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_09():
    result = parse("DRB1*11:09")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_100():
    result = parse("DRB1*11:100")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_101_01():
    result = parse("DRB1*11:101:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:101:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:101:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_101_02():
    result = parse("DRB1*11:101:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:101:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:101:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_102_01():
    result = parse("DRB1*11:102:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:102:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:102:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_102_02():
    result = parse("DRB1*11:102:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:102:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:102:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_103_01():
    result = parse("DRB1*11:103:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:103:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:103:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_103_02():
    result = parse("DRB1*11:103:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:103:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:103:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_104():
    result = parse("DRB1*11:104")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_105():
    result = parse("DRB1*11:105")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_106():
    result = parse("DRB1*11:106")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_107():
    result = parse("DRB1*11:107")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_108():
    result = parse("DRB1*11:108")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_109():
    result = parse("DRB1*11:109")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_10_01():
    result = parse("DRB1*11:10:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:10:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:10:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_10_02():
    result = parse("DRB1*11:10:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:10:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:10:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_110():
    result = parse("DRB1*11:110")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_111():
    result = parse("DRB1*11:111")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_112():
    result = parse("DRB1*11:112")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_113():
    result = parse("DRB1*11:113")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_114():
    result = parse("DRB1*11:114")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_115():
    result = parse("DRB1*11:115")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:115") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_116():
    result = parse("DRB1*11:116")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_117_01():
    result = parse("DRB1*11:117:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:117:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:117:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_117_02():
    result = parse("DRB1*11:117:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:117:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:117:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_118():
    result = parse("DRB1*11:118")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:118") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_119():
    result = parse("DRB1*11:119")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:119") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_11_01():
    result = parse("DRB1*11:11:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:11:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:11:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_11_03():
    result = parse("DRB1*11:11:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:11:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:11:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_120():
    result = parse("DRB1*11:120")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:120") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_121():
    result = parse("DRB1*11:121")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:121") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_122():
    result = parse("DRB1*11:122")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:122") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_123():
    result = parse("DRB1*11:123")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:123") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_124_01():
    result = parse("DRB1*11:124:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:124:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:124:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_124_02():
    result = parse("DRB1*11:124:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:124:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:124:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_125():
    result = parse("DRB1*11:125")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:125") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_126():
    result = parse("DRB1*11:126")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:126") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_127():
    result = parse("DRB1*11:127")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:127") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_128():
    result = parse("DRB1*11:128")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:128") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_129():
    result = parse("DRB1*11:129")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:129") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_12_01():
    result = parse("DRB1*11:12:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:12:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:12:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_12_02():
    result = parse("DRB1*11:12:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:12:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:12:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_12_03():
    result = parse("DRB1*11:12:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:12:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:12:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_130():
    result = parse("DRB1*11:130")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:130") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_131():
    result = parse("DRB1*11:131")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:131") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_132():
    result = parse("DRB1*11:132")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:132") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_133():
    result = parse("DRB1*11:133")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:133") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_134():
    result = parse("DRB1*11:134")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:134") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_135():
    result = parse("DRB1*11:135")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:135") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_136():
    result = parse("DRB1*11:136")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:136") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_137():
    result = parse("DRB1*11:137")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:137") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_138():
    result = parse("DRB1*11:138")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:138") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_139():
    result = parse("DRB1*11:139")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:139") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_13_01():
    result = parse("DRB1*11:13:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:13:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:13:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_13_02():
    result = parse("DRB1*11:13:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:13:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:13:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_140():
    result = parse("DRB1*11:140")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:140") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_141():
    result = parse("DRB1*11:141")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:141") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_142():
    result = parse("DRB1*11:142")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:142") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_143():
    result = parse("DRB1*11:143")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:143") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_144():
    result = parse("DRB1*11:144")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:144") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_145():
    result = parse("DRB1*11:145")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:145") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_146():
    result = parse("DRB1*11:146")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:146") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_147_01():
    result = parse("DRB1*11:147:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:147:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:147:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_147_02():
    result = parse("DRB1*11:147:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:147:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:147:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_148():
    result = parse("DRB1*11:148")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:148") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_149():
    result = parse("DRB1*11:149")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:149") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_14_01():
    result = parse("DRB1*11:14:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:14:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:14:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_14_02():
    result = parse("DRB1*11:14:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:14:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:14:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_15():
    result = parse("DRB1*11:15")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_150():
    result = parse("DRB1*11:150")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:150") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_151():
    result = parse("DRB1*11:151")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:151") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_152():
    result = parse("DRB1*11:152")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:152") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_153():
    result = parse("DRB1*11:153")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:153") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_154():
    result = parse("DRB1*11:154")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:154") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_155():
    result = parse("DRB1*11:155")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:155") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_156():
    result = parse("DRB1*11:156")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:156") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_157():
    result = parse("DRB1*11:157")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:157") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_158():
    result = parse("DRB1*11:158")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:158") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_159():
    result = parse("DRB1*11:159")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:159") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_16():
    result = parse("DRB1*11:16")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_160():
    result = parse("DRB1*11:160")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:160") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_161():
    result = parse("DRB1*11:161")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:161") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_162():
    result = parse("DRB1*11:162")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:162") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_163():
    result = parse("DRB1*11:163")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:163") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_164():
    result = parse("DRB1*11:164")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:164") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_165_01():
    result = parse("DRB1*11:165:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:165:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:165:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_165_02():
    result = parse("DRB1*11:165:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:165:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:165:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_166():
    result = parse("DRB1*11:166")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:166") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_167():
    result = parse("DRB1*11:167")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:167") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_168():
    result = parse("DRB1*11:168")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:168") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_169N():
    result = parse("DRB1*11:169N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:169N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:169N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_17():
    result = parse("DRB1*11:17")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_170():
    result = parse("DRB1*11:170")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:170") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_171():
    result = parse("DRB1*11:171")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:171") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_172():
    result = parse("DRB1*11:172")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:172") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_173():
    result = parse("DRB1*11:173")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:173") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_174():
    result = parse("DRB1*11:174")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:174") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_175():
    result = parse("DRB1*11:175")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:175") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_176():
    result = parse("DRB1*11:176")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:176") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_177():
    result = parse("DRB1*11:177")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:177") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_178():
    result = parse("DRB1*11:178")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:178") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_179():
    result = parse("DRB1*11:179")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:179") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_18():
    result = parse("DRB1*11:18")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_180():
    result = parse("DRB1*11:180")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:180") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_181():
    result = parse("DRB1*11:181")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:181") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_182():
    result = parse("DRB1*11:182")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:182") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_183():
    result = parse("DRB1*11:183")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:183") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_184():
    result = parse("DRB1*11:184")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:184") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_185():
    result = parse("DRB1*11:185")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:185") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_186():
    result = parse("DRB1*11:186")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:186") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_187():
    result = parse("DRB1*11:187")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:187") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_188():
    result = parse("DRB1*11:188")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:188") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_189():
    result = parse("DRB1*11:189")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:189") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_190():
    result = parse("DRB1*11:190")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:190") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_191():
    result = parse("DRB1*11:191")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:191") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_192():
    result = parse("DRB1*11:192")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:192") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_193_01():
    result = parse("DRB1*11:193:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:193:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:193:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_193_02():
    result = parse("DRB1*11:193:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:193:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:193:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_194():
    result = parse("DRB1*11:194")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:194") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_195():
    result = parse("DRB1*11:195")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:195") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_196():
    result = parse("DRB1*11:196")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:196") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_197():
    result = parse("DRB1*11:197")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:197") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_198():
    result = parse("DRB1*11:198")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:198") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_199():
    result = parse("DRB1*11:199")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:199") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_19_01():
    result = parse("DRB1*11:19:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:19:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:19:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_19_02():
    result = parse("DRB1*11:19:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:19:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:19:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_19_03():
    result = parse("DRB1*11:19:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:19:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:19:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_20():
    result = parse("DRB1*11:20")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_200():
    result = parse("DRB1*11:200")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:200") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_201():
    result = parse("DRB1*11:201")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:201") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_202():
    result = parse("DRB1*11:202")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:202") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_203():
    result = parse("DRB1*11:203")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:203") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_204():
    result = parse("DRB1*11:204")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:204") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_205():
    result = parse("DRB1*11:205")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:205") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_206():
    result = parse("DRB1*11:206")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:206") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_207():
    result = parse("DRB1*11:207")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:207") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_208():
    result = parse("DRB1*11:208")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:208") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_209():
    result = parse("DRB1*11:209")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:209") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_21():
    result = parse("DRB1*11:21")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_210():
    result = parse("DRB1*11:210")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:210") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_211():
    result = parse("DRB1*11:211")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:211") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_212():
    result = parse("DRB1*11:212")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:212") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_213():
    result = parse("DRB1*11:213")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:213") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_214():
    result = parse("DRB1*11:214")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:214") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_215():
    result = parse("DRB1*11:215")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:215") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_216():
    result = parse("DRB1*11:216")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:216") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_217N():
    result = parse("DRB1*11:217N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:217N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:217N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_218():
    result = parse("DRB1*11:218")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:218") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_219():
    result = parse("DRB1*11:219")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:219") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_22():
    result = parse("DRB1*11:22")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_220():
    result = parse("DRB1*11:220")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:220") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_221():
    result = parse("DRB1*11:221")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:221") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_222():
    result = parse("DRB1*11:222")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:222") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_223():
    result = parse("DRB1*11:223")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:223") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_224():
    result = parse("DRB1*11:224")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:224") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_225():
    result = parse("DRB1*11:225")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:225") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_226():
    result = parse("DRB1*11:226")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:226") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_227():
    result = parse("DRB1*11:227")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:227") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_228():
    result = parse("DRB1*11:228")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:228") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_229():
    result = parse("DRB1*11:229")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:229") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_230():
    result = parse("DRB1*11:230")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:230") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_231():
    result = parse("DRB1*11:231")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:231") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_232():
    result = parse("DRB1*11:232")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:232") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_233():
    result = parse("DRB1*11:233")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:233") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_234():
    result = parse("DRB1*11:234")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:234") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_235():
    result = parse("DRB1*11:235")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:235") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_236():
    result = parse("DRB1*11:236")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:236") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_237():
    result = parse("DRB1*11:237")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:237") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_238():
    result = parse("DRB1*11:238")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:238") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_239():
    result = parse("DRB1*11:239")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:239") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_23_01():
    result = parse("DRB1*11:23:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:23:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:23:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_23_02():
    result = parse("DRB1*11:23:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:23:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:23:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_240():
    result = parse("DRB1*11:240")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:240") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_241():
    result = parse("DRB1*11:241")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:241") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_242():
    result = parse("DRB1*11:242")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:242") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_243():
    result = parse("DRB1*11:243")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:243") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_244():
    result = parse("DRB1*11:244")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:244") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_245():
    result = parse("DRB1*11:245")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:245") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_246N():
    result = parse("DRB1*11:246N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:246N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:246N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_247():
    result = parse("DRB1*11:247")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:247") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_248Q():
    result = parse("DRB1*11:248Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:248Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:248Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_249():
    result = parse("DRB1*11:249")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:249") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_24_01():
    result = parse("DRB1*11:24:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:24:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:24:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_24_02():
    result = parse("DRB1*11:24:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:24:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:24:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_25():
    result = parse("DRB1*11:25")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_250N():
    result = parse("DRB1*11:250N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:250N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:250N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_251():
    result = parse("DRB1*11:251")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:251") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_252():
    result = parse("DRB1*11:252")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:252") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_253():
    result = parse("DRB1*11:253")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:253") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_254():
    result = parse("DRB1*11:254")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:254") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_255():
    result = parse("DRB1*11:255")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:255") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_256():
    result = parse("DRB1*11:256")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:256") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_257():
    result = parse("DRB1*11:257")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:257") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_258():
    result = parse("DRB1*11:258")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:258") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_259():
    result = parse("DRB1*11:259")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:259") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_26():
    result = parse("DRB1*11:26")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_260():
    result = parse("DRB1*11:260")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:260") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_261():
    result = parse("DRB1*11:261")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:261") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_262():
    result = parse("DRB1*11:262")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:262") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_263():
    result = parse("DRB1*11:263")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:263") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_264():
    result = parse("DRB1*11:264")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:264") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_265():
    result = parse("DRB1*11:265")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:265") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_266():
    result = parse("DRB1*11:266")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:266") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_267():
    result = parse("DRB1*11:267")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:267") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_268():
    result = parse("DRB1*11:268")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:268") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_269():
    result = parse("DRB1*11:269")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:269") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_270():
    result = parse("DRB1*11:270")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:270") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_271():
    result = parse("DRB1*11:271")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:271") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_272Q():
    result = parse("DRB1*11:272Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:272Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:272Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_273():
    result = parse("DRB1*11:273")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:273") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_27_01():
    result = parse("DRB1*11:27:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:27:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:27:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_27_02():
    result = parse("DRB1*11:27:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:27:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:27:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_27_03():
    result = parse("DRB1*11:27:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:27:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:27:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_28_01():
    result = parse("DRB1*11:28:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:28:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:28:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_28_02():
    result = parse("DRB1*11:28:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:28:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:28:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_28_03():
    result = parse("DRB1*11:28:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:28:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:28:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_29_01():
    result = parse("DRB1*11:29:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:29:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:29:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_29_02():
    result = parse("DRB1*11:29:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:29:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:29:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_30():
    result = parse("DRB1*11:30")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_31():
    result = parse("DRB1*11:31")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_32():
    result = parse("DRB1*11:32")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_33():
    result = parse("DRB1*11:33")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_34():
    result = parse("DRB1*11:34")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_35():
    result = parse("DRB1*11:35")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_36():
    result = parse("DRB1*11:36")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_37_01():
    result = parse("DRB1*11:37:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:37:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:37:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_37_02():
    result = parse("DRB1*11:37:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:37:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:37:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_38():
    result = parse("DRB1*11:38")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_39():
    result = parse("DRB1*11:39")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_40():
    result = parse("DRB1*11:40")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_41():
    result = parse("DRB1*11:41")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_42_01():
    result = parse("DRB1*11:42:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:42:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:42:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_42_02():
    result = parse("DRB1*11:42:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:42:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:42:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_43():
    result = parse("DRB1*11:43")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_44():
    result = parse("DRB1*11:44")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_45():
    result = parse("DRB1*11:45")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_46_01():
    result = parse("DRB1*11:46:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:46:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:46:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_46_02():
    result = parse("DRB1*11:46:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:46:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:46:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_47():
    result = parse("DRB1*11:47")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_48():
    result = parse("DRB1*11:48")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_49_01():
    result = parse("DRB1*11:49:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:49:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:49:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_49_02():
    result = parse("DRB1*11:49:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:49:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:49:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_50():
    result = parse("DRB1*11:50")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_51():
    result = parse("DRB1*11:51")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_52():
    result = parse("DRB1*11:52")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_53():
    result = parse("DRB1*11:53")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_54_01():
    result = parse("DRB1*11:54:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:54:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:54:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_54_02():
    result = parse("DRB1*11:54:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:54:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:54:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_55():
    result = parse("DRB1*11:55")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_56():
    result = parse("DRB1*11:56")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_57():
    result = parse("DRB1*11:57")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_58_01():
    result = parse("DRB1*11:58:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:58:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:58:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_58_02():
    result = parse("DRB1*11:58:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:58:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:58:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_59():
    result = parse("DRB1*11:59")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_60():
    result = parse("DRB1*11:60")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_61():
    result = parse("DRB1*11:61")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_62_01():
    result = parse("DRB1*11:62:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:62:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:62:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_62_02():
    result = parse("DRB1*11:62:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:62:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:62:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_63_01():
    result = parse("DRB1*11:63:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:63:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:63:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_63_02():
    result = parse("DRB1*11:63:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:63:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:63:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_64():
    result = parse("DRB1*11:64")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_65_01():
    result = parse("DRB1*11:65:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:65:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:65:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_65_02():
    result = parse("DRB1*11:65:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:65:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:65:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_66_01():
    result = parse("DRB1*11:66:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:66:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:66:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_66_02():
    result = parse("DRB1*11:66:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:66:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:66:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_67():
    result = parse("DRB1*11:67")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_68():
    result = parse("DRB1*11:68")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_69():
    result = parse("DRB1*11:69")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_70():
    result = parse("DRB1*11:70")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_72():
    result = parse("DRB1*11:72")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_73():
    result = parse("DRB1*11:73")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_74_01():
    result = parse("DRB1*11:74:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:74:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:74:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_74_02():
    result = parse("DRB1*11:74:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:74:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:74:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_75():
    result = parse("DRB1*11:75")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_76():
    result = parse("DRB1*11:76")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_77():
    result = parse("DRB1*11:77")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_78():
    result = parse("DRB1*11:78")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_79():
    result = parse("DRB1*11:79")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_80():
    result = parse("DRB1*11:80")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_81():
    result = parse("DRB1*11:81")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_82():
    result = parse("DRB1*11:82")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_83():
    result = parse("DRB1*11:83")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_84_01():
    result = parse("DRB1*11:84:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:84:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:84:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_84_02():
    result = parse("DRB1*11:84:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:84:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:84:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_84_03():
    result = parse("DRB1*11:84:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*11:84:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*11:84:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_85():
    result = parse("DRB1*11:85")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_86():
    result = parse("DRB1*11:86")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_87():
    result = parse("DRB1*11:87")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_88():
    result = parse("DRB1*11:88")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_89():
    result = parse("DRB1*11:89")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_90():
    result = parse("DRB1*11:90")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_91():
    result = parse("DRB1*11:91")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_92():
    result = parse("DRB1*11:92")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_93():
    result = parse("DRB1*11:93")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_94():
    result = parse("DRB1*11:94")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_95():
    result = parse("DRB1*11:95")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_96():
    result = parse("DRB1*11:96")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_97():
    result = parse("DRB1*11:97")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_98():
    result = parse("DRB1*11:98")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_11_99():
    result = parse("DRB1*11:99")
    assert result.__class__ is Allele, f'Expected parse("DRB1*11:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*11:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_01_01_01():
    result = parse("DRB1*12:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*12:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_01_01_02():
    result = parse("DRB1*12:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*12:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_01_01_03():
    result = parse("DRB1*12:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*12:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_01_01_04():
    result = parse("DRB1*12:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*12:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_01_01_05():
    result = parse("DRB1*12:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*12:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_01_01_06():
    result = parse("DRB1*12:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*12:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_01_02():
    result = parse("DRB1*12:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_01_03():
    result = parse("DRB1*12:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_01_04():
    result = parse("DRB1*12:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_01_05():
    result = parse("DRB1*12:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_01_06():
    result = parse("DRB1*12:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_01_07():
    result = parse("DRB1*12:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_01_08():
    result = parse("DRB1*12:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_01_09():
    result = parse("DRB1*12:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_02_01_01():
    result = parse("DRB1*12:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*12:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_02_01_02():
    result = parse("DRB1*12:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*12:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_02_01_03():
    result = parse("DRB1*12:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*12:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_02_01_04():
    result = parse("DRB1*12:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*12:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_02_01_05():
    result = parse("DRB1*12:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*12:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_02_01_06():
    result = parse("DRB1*12:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*12:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_02_02():
    result = parse("DRB1*12:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_02_03():
    result = parse("DRB1*12:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_02_04():
    result = parse("DRB1*12:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_02_05():
    result = parse("DRB1*12:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_02_06():
    result = parse("DRB1*12:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_02_07():
    result = parse("DRB1*12:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_02_08():
    result = parse("DRB1*12:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_02_09():
    result = parse("DRB1*12:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_02_10():
    result = parse("DRB1*12:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_03_02():
    result = parse("DRB1*12:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_03_03():
    result = parse("DRB1*12:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_04():
    result = parse("DRB1*12:04")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_05():
    result = parse("DRB1*12:05")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_06():
    result = parse("DRB1*12:06")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_07():
    result = parse("DRB1*12:07")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_08():
    result = parse("DRB1*12:08")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_09():
    result = parse("DRB1*12:09")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_10():
    result = parse("DRB1*12:10")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_11():
    result = parse("DRB1*12:11")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_12():
    result = parse("DRB1*12:12")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_13():
    result = parse("DRB1*12:13")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_14():
    result = parse("DRB1*12:14")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_15():
    result = parse("DRB1*12:15")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_16_01():
    result = parse("DRB1*12:16:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:16:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:16:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_16_02():
    result = parse("DRB1*12:16:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:16:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:16:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_16_03():
    result = parse("DRB1*12:16:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:16:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*12:16:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_17():
    result = parse("DRB1*12:17")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_18():
    result = parse("DRB1*12:18")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_19():
    result = parse("DRB1*12:19")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_20():
    result = parse("DRB1*12:20")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_21():
    result = parse("DRB1*12:21")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_22():
    result = parse("DRB1*12:22")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_23():
    result = parse("DRB1*12:23")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_24N():
    result = parse("DRB1*12:24N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:24N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:24N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_25():
    result = parse("DRB1*12:25")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_26():
    result = parse("DRB1*12:26")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_27():
    result = parse("DRB1*12:27")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_28():
    result = parse("DRB1*12:28")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_29():
    result = parse("DRB1*12:29")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_30():
    result = parse("DRB1*12:30")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_31N():
    result = parse("DRB1*12:31N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:31N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:31N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_32():
    result = parse("DRB1*12:32")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_33():
    result = parse("DRB1*12:33")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_34():
    result = parse("DRB1*12:34")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_35():
    result = parse("DRB1*12:35")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_36():
    result = parse("DRB1*12:36")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_37():
    result = parse("DRB1*12:37")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_38():
    result = parse("DRB1*12:38")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_39():
    result = parse("DRB1*12:39")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_40():
    result = parse("DRB1*12:40")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_41():
    result = parse("DRB1*12:41")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_42():
    result = parse("DRB1*12:42")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_43():
    result = parse("DRB1*12:43")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_44():
    result = parse("DRB1*12:44")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_45():
    result = parse("DRB1*12:45")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_46():
    result = parse("DRB1*12:46")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_47():
    result = parse("DRB1*12:47")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_48():
    result = parse("DRB1*12:48")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_49():
    result = parse("DRB1*12:49")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_50():
    result = parse("DRB1*12:50")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_51():
    result = parse("DRB1*12:51")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_52():
    result = parse("DRB1*12:52")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_53():
    result = parse("DRB1*12:53")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_54():
    result = parse("DRB1*12:54")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_55():
    result = parse("DRB1*12:55")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_56():
    result = parse("DRB1*12:56")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_57():
    result = parse("DRB1*12:57")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_58():
    result = parse("DRB1*12:58")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_59():
    result = parse("DRB1*12:59")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_60N():
    result = parse("DRB1*12:60N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:60N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:60N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_61():
    result = parse("DRB1*12:61")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_62():
    result = parse("DRB1*12:62")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_63():
    result = parse("DRB1*12:63")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_64():
    result = parse("DRB1*12:64")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_65():
    result = parse("DRB1*12:65")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_66():
    result = parse("DRB1*12:66")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_67():
    result = parse("DRB1*12:67")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_68():
    result = parse("DRB1*12:68")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_69():
    result = parse("DRB1*12:69")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_70():
    result = parse("DRB1*12:70")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_71():
    result = parse("DRB1*12:71")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_72N():
    result = parse("DRB1*12:72N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:72N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:72N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_73():
    result = parse("DRB1*12:73")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_74N():
    result = parse("DRB1*12:74N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*12:74N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:74N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_75():
    result = parse("DRB1*12:75")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_76():
    result = parse("DRB1*12:76")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_77():
    result = parse("DRB1*12:77")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_78():
    result = parse("DRB1*12:78")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_79():
    result = parse("DRB1*12:79")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_80():
    result = parse("DRB1*12:80")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_81():
    result = parse("DRB1*12:81")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_82():
    result = parse("DRB1*12:82")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_83():
    result = parse("DRB1*12:83")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_12_84():
    result = parse("DRB1*12:84")
    assert result.__class__ is Allele, f'Expected parse("DRB1*12:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*12:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_01_01():
    result = parse("DRB1*13:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*13:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_01_02():
    result = parse("DRB1*13:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*13:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_01_03():
    result = parse("DRB1*13:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*13:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_02():
    result = parse("DRB1*13:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_03():
    result = parse("DRB1*13:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_04():
    result = parse("DRB1*13:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_05():
    result = parse("DRB1*13:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_06():
    result = parse("DRB1*13:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_07():
    result = parse("DRB1*13:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_08():
    result = parse("DRB1*13:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_09():
    result = parse("DRB1*13:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_10():
    result = parse("DRB1*13:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_11():
    result = parse("DRB1*13:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_12():
    result = parse("DRB1*13:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_13():
    result = parse("DRB1*13:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_14():
    result = parse("DRB1*13:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_15():
    result = parse("DRB1*13:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_16():
    result = parse("DRB1*13:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_17():
    result = parse("DRB1*13:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_18():
    result = parse("DRB1*13:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_19():
    result = parse("DRB1*13:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_20():
    result = parse("DRB1*13:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_21():
    result = parse("DRB1*13:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_22():
    result = parse("DRB1*13:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_23():
    result = parse("DRB1*13:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_24():
    result = parse("DRB1*13:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_25():
    result = parse("DRB1*13:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_26():
    result = parse("DRB1*13:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_27():
    result = parse("DRB1*13:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_28():
    result = parse("DRB1*13:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_01_29():
    result = parse("DRB1*13:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_01_01():
    result = parse("DRB1*13:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*13:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_01_02():
    result = parse("DRB1*13:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*13:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_01_03():
    result = parse("DRB1*13:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*13:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_01_04():
    result = parse("DRB1*13:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*13:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_01_05():
    result = parse("DRB1*13:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*13:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_02():
    result = parse("DRB1*13:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_03():
    result = parse("DRB1*13:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_04():
    result = parse("DRB1*13:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_05():
    result = parse("DRB1*13:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_06():
    result = parse("DRB1*13:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_07():
    result = parse("DRB1*13:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_08():
    result = parse("DRB1*13:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_09():
    result = parse("DRB1*13:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_10():
    result = parse("DRB1*13:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_11():
    result = parse("DRB1*13:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_12():
    result = parse("DRB1*13:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_13():
    result = parse("DRB1*13:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_14():
    result = parse("DRB1*13:02:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_15():
    result = parse("DRB1*13:02:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_16():
    result = parse("DRB1*13:02:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_02_17():
    result = parse("DRB1*13:02:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:02:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_03_01():
    result = parse("DRB1*13:03:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:03:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:03:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_03_02():
    result = parse("DRB1*13:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_03_03():
    result = parse("DRB1*13:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_03_04():
    result = parse("DRB1*13:03:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:03:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_03_05():
    result = parse("DRB1*13:03:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:03:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_03_06():
    result = parse("DRB1*13:03:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:03:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_03_07():
    result = parse("DRB1*13:03:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:03:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_03_08():
    result = parse("DRB1*13:03:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:03:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:03:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_03_09():
    result = parse("DRB1*13:03:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:03:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:03:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_04():
    result = parse("DRB1*13:04")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_05_01():
    result = parse("DRB1*13:05:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:05:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_05_02():
    result = parse("DRB1*13:05:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:05:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_05_03():
    result = parse("DRB1*13:05:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:05:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:05:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_06():
    result = parse("DRB1*13:06")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_07_01():
    result = parse("DRB1*13:07:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:07:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_07_02():
    result = parse("DRB1*13:07:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:07:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_08():
    result = parse("DRB1*13:08")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_09():
    result = parse("DRB1*13:09")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_10():
    result = parse("DRB1*13:10")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_100():
    result = parse("DRB1*13:100")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_101():
    result = parse("DRB1*13:101")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_102():
    result = parse("DRB1*13:102")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_103():
    result = parse("DRB1*13:103")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_104():
    result = parse("DRB1*13:104")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_105():
    result = parse("DRB1*13:105")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_106():
    result = parse("DRB1*13:106")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_107():
    result = parse("DRB1*13:107")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_108():
    result = parse("DRB1*13:108")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_109():
    result = parse("DRB1*13:109")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_110():
    result = parse("DRB1*13:110")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_111():
    result = parse("DRB1*13:111")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_112():
    result = parse("DRB1*13:112")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_113N():
    result = parse("DRB1*13:113N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:113N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:113N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_114():
    result = parse("DRB1*13:114")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_115():
    result = parse("DRB1*13:115")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:115") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_116():
    result = parse("DRB1*13:116")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_117():
    result = parse("DRB1*13:117")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_118():
    result = parse("DRB1*13:118")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:118") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_119():
    result = parse("DRB1*13:119")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:119") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_11_01():
    result = parse("DRB1*13:11:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:11:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:11:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_11_02():
    result = parse("DRB1*13:11:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:11:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:11:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_120():
    result = parse("DRB1*13:120")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:120") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_121():
    result = parse("DRB1*13:121")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:121") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_122():
    result = parse("DRB1*13:122")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:122") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_123():
    result = parse("DRB1*13:123")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:123") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_124():
    result = parse("DRB1*13:124")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:124") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_125():
    result = parse("DRB1*13:125")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:125") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_126():
    result = parse("DRB1*13:126")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:126") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_127():
    result = parse("DRB1*13:127")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:127") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_128():
    result = parse("DRB1*13:128")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:128") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_129():
    result = parse("DRB1*13:129")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:129") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_12_01():
    result = parse("DRB1*13:12:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:12:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:12:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_12_02():
    result = parse("DRB1*13:12:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:12:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:12:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_12_03():
    result = parse("DRB1*13:12:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:12:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:12:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_12_04():
    result = parse("DRB1*13:12:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:12:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:12:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_13():
    result = parse("DRB1*13:13")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_130():
    result = parse("DRB1*13:130")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:130") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_131():
    result = parse("DRB1*13:131")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:131") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_132():
    result = parse("DRB1*13:132")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:132") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_133():
    result = parse("DRB1*13:133")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:133") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_134():
    result = parse("DRB1*13:134")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:134") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_135():
    result = parse("DRB1*13:135")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:135") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_136():
    result = parse("DRB1*13:136")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:136") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_137N():
    result = parse("DRB1*13:137N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:137N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:137N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_138():
    result = parse("DRB1*13:138")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:138") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_139():
    result = parse("DRB1*13:139")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:139") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_140():
    result = parse("DRB1*13:140")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:140") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_141():
    result = parse("DRB1*13:141")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:141") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_142N():
    result = parse("DRB1*13:142N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:142N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:142N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_143():
    result = parse("DRB1*13:143")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:143") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_144():
    result = parse("DRB1*13:144")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:144") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_145():
    result = parse("DRB1*13:145")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:145") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_146():
    result = parse("DRB1*13:146")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:146") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_147():
    result = parse("DRB1*13:147")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:147") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_148():
    result = parse("DRB1*13:148")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:148") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_149():
    result = parse("DRB1*13:149")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:149") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_14_01():
    result = parse("DRB1*13:14:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:14:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:14:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_14_02():
    result = parse("DRB1*13:14:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:14:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:14:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_14_03():
    result = parse("DRB1*13:14:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:14:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:14:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_15():
    result = parse("DRB1*13:15")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_150():
    result = parse("DRB1*13:150")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:150") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_151():
    result = parse("DRB1*13:151")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:151") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_152():
    result = parse("DRB1*13:152")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:152") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_153():
    result = parse("DRB1*13:153")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:153") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_154():
    result = parse("DRB1*13:154")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:154") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_155():
    result = parse("DRB1*13:155")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:155") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_156():
    result = parse("DRB1*13:156")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:156") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_157():
    result = parse("DRB1*13:157")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:157") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_158():
    result = parse("DRB1*13:158")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:158") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_159():
    result = parse("DRB1*13:159")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:159") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_16():
    result = parse("DRB1*13:16")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_160():
    result = parse("DRB1*13:160")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:160") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_161():
    result = parse("DRB1*13:161")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:161") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_162():
    result = parse("DRB1*13:162")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:162") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_163():
    result = parse("DRB1*13:163")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:163") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_164():
    result = parse("DRB1*13:164")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:164") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_165():
    result = parse("DRB1*13:165")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:165") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_166():
    result = parse("DRB1*13:166")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:166") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_167():
    result = parse("DRB1*13:167")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:167") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_168():
    result = parse("DRB1*13:168")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:168") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_169():
    result = parse("DRB1*13:169")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:169") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_17():
    result = parse("DRB1*13:17")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_170():
    result = parse("DRB1*13:170")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:170") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_171_01():
    result = parse("DRB1*13:171:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:171:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:171:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_171_02():
    result = parse("DRB1*13:171:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:171:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:171:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_172():
    result = parse("DRB1*13:172")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:172") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_173():
    result = parse("DRB1*13:173")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:173") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_174():
    result = parse("DRB1*13:174")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:174") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_175():
    result = parse("DRB1*13:175")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:175") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_176():
    result = parse("DRB1*13:176")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:176") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_177():
    result = parse("DRB1*13:177")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:177") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_178():
    result = parse("DRB1*13:178")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:178") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_179():
    result = parse("DRB1*13:179")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:179") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_18():
    result = parse("DRB1*13:18")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_180():
    result = parse("DRB1*13:180")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:180") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_181():
    result = parse("DRB1*13:181")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:181") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_182():
    result = parse("DRB1*13:182")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:182") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_183():
    result = parse("DRB1*13:183")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:183") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_184():
    result = parse("DRB1*13:184")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:184") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_185N():
    result = parse("DRB1*13:185N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:185N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:185N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_186():
    result = parse("DRB1*13:186")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:186") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_187():
    result = parse("DRB1*13:187")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:187") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_188():
    result = parse("DRB1*13:188")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:188") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_189():
    result = parse("DRB1*13:189")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:189") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_19():
    result = parse("DRB1*13:19")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_190():
    result = parse("DRB1*13:190")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:190") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_191():
    result = parse("DRB1*13:191")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:191") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_192():
    result = parse("DRB1*13:192")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:192") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_193():
    result = parse("DRB1*13:193")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:193") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_194():
    result = parse("DRB1*13:194")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:194") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_195():
    result = parse("DRB1*13:195")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:195") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_196():
    result = parse("DRB1*13:196")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:196") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_197():
    result = parse("DRB1*13:197")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:197") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_198():
    result = parse("DRB1*13:198")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:198") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_199():
    result = parse("DRB1*13:199")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:199") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_20():
    result = parse("DRB1*13:20")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_200N():
    result = parse("DRB1*13:200N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:200N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:200N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_201():
    result = parse("DRB1*13:201")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:201") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_202():
    result = parse("DRB1*13:202")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:202") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_203():
    result = parse("DRB1*13:203")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:203") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_204():
    result = parse("DRB1*13:204")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:204") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_205():
    result = parse("DRB1*13:205")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:205") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_206():
    result = parse("DRB1*13:206")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:206") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_207():
    result = parse("DRB1*13:207")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:207") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_208():
    result = parse("DRB1*13:208")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:208") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_209():
    result = parse("DRB1*13:209")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:209") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_210():
    result = parse("DRB1*13:210")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:210") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_211():
    result = parse("DRB1*13:211")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:211") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_212():
    result = parse("DRB1*13:212")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:212") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_213():
    result = parse("DRB1*13:213")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:213") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_214():
    result = parse("DRB1*13:214")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:214") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_215():
    result = parse("DRB1*13:215")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:215") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_216():
    result = parse("DRB1*13:216")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:216") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_217():
    result = parse("DRB1*13:217")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:217") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_218():
    result = parse("DRB1*13:218")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:218") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_219():
    result = parse("DRB1*13:219")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:219") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_21_01():
    result = parse("DRB1*13:21:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:21:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:21:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_21_02():
    result = parse("DRB1*13:21:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:21:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:21:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_220():
    result = parse("DRB1*13:220")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:220") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_221():
    result = parse("DRB1*13:221")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:221") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_222():
    result = parse("DRB1*13:222")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:222") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_223():
    result = parse("DRB1*13:223")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:223") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_224():
    result = parse("DRB1*13:224")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:224") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_225():
    result = parse("DRB1*13:225")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:225") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_226():
    result = parse("DRB1*13:226")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:226") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_227():
    result = parse("DRB1*13:227")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:227") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_228():
    result = parse("DRB1*13:228")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:228") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_229():
    result = parse("DRB1*13:229")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:229") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_22_01():
    result = parse("DRB1*13:22:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:22:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:22:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_22_02():
    result = parse("DRB1*13:22:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:22:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:22:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_230():
    result = parse("DRB1*13:230")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:230") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_231():
    result = parse("DRB1*13:231")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:231") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_232():
    result = parse("DRB1*13:232")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:232") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_233():
    result = parse("DRB1*13:233")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:233") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_234():
    result = parse("DRB1*13:234")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:234") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_235():
    result = parse("DRB1*13:235")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:235") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_236():
    result = parse("DRB1*13:236")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:236") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_237():
    result = parse("DRB1*13:237")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:237") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_238():
    result = parse("DRB1*13:238")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:238") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_239():
    result = parse("DRB1*13:239")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:239") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_23_01():
    result = parse("DRB1*13:23:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:23:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:23:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_23_02():
    result = parse("DRB1*13:23:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:23:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:23:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_24():
    result = parse("DRB1*13:24")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_240():
    result = parse("DRB1*13:240")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:240") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_241():
    result = parse("DRB1*13:241")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:241") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_242_01():
    result = parse("DRB1*13:242:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:242:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:242:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_242_02():
    result = parse("DRB1*13:242:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:242:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:242:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_243():
    result = parse("DRB1*13:243")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:243") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_244():
    result = parse("DRB1*13:244")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:244") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_245():
    result = parse("DRB1*13:245")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:245") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_246():
    result = parse("DRB1*13:246")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:246") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_247():
    result = parse("DRB1*13:247")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:247") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_248():
    result = parse("DRB1*13:248")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:248") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_249N():
    result = parse("DRB1*13:249N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:249N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:249N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_25():
    result = parse("DRB1*13:25")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_250():
    result = parse("DRB1*13:250")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:250") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_251():
    result = parse("DRB1*13:251")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:251") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_252N():
    result = parse("DRB1*13:252N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:252N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:252N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_253():
    result = parse("DRB1*13:253")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:253") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_254():
    result = parse("DRB1*13:254")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:254") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_255N():
    result = parse("DRB1*13:255N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:255N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:255N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_256():
    result = parse("DRB1*13:256")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:256") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_257():
    result = parse("DRB1*13:257")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:257") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_258():
    result = parse("DRB1*13:258")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:258") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_259():
    result = parse("DRB1*13:259")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:259") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_260():
    result = parse("DRB1*13:260")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:260") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_261():
    result = parse("DRB1*13:261")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:261") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_262():
    result = parse("DRB1*13:262")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:262") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_263():
    result = parse("DRB1*13:263")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:263") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_264():
    result = parse("DRB1*13:264")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:264") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_265():
    result = parse("DRB1*13:265")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:265") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_266():
    result = parse("DRB1*13:266")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:266") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_267():
    result = parse("DRB1*13:267")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:267") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_268N():
    result = parse("DRB1*13:268N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:268N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:268N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_269():
    result = parse("DRB1*13:269")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:269") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_26_01():
    result = parse("DRB1*13:26:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:26:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:26:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_26_02():
    result = parse("DRB1*13:26:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:26:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:26:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_270():
    result = parse("DRB1*13:270")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:270") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_271():
    result = parse("DRB1*13:271")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:271") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_272():
    result = parse("DRB1*13:272")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:272") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_273():
    result = parse("DRB1*13:273")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:273") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_274():
    result = parse("DRB1*13:274")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:274") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_275():
    result = parse("DRB1*13:275")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:275") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_276():
    result = parse("DRB1*13:276")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:276") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_277():
    result = parse("DRB1*13:277")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:277") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_278Q():
    result = parse("DRB1*13:278Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:278Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:278Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_279():
    result = parse("DRB1*13:279")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:279") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_27_01():
    result = parse("DRB1*13:27:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:27:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:27:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_27_02():
    result = parse("DRB1*13:27:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:27:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:27:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_280():
    result = parse("DRB1*13:280")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:280") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_281():
    result = parse("DRB1*13:281")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:281") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_282():
    result = parse("DRB1*13:282")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:282") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_283():
    result = parse("DRB1*13:283")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:283") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_284():
    result = parse("DRB1*13:284")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:284") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_285():
    result = parse("DRB1*13:285")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:285") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_286():
    result = parse("DRB1*13:286")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:286") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_287():
    result = parse("DRB1*13:287")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:287") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:287") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_288():
    result = parse("DRB1*13:288")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:288") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_289N():
    result = parse("DRB1*13:289N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:289N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:289N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_28_01():
    result = parse("DRB1*13:28:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:28:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:28:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_28_02():
    result = parse("DRB1*13:28:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:28:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:28:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_29():
    result = parse("DRB1*13:29")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_290():
    result = parse("DRB1*13:290")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:290") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_291():
    result = parse("DRB1*13:291")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:291") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_292():
    result = parse("DRB1*13:292")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:292") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_293():
    result = parse("DRB1*13:293")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:293") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_294():
    result = parse("DRB1*13:294")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:294") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_295N():
    result = parse("DRB1*13:295N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:295N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:295N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_296():
    result = parse("DRB1*13:296")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:296") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_297():
    result = parse("DRB1*13:297")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:297") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_298N():
    result = parse("DRB1*13:298N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:298N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:298N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_299():
    result = parse("DRB1*13:299")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:299") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_30():
    result = parse("DRB1*13:30")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_300():
    result = parse("DRB1*13:300")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:300") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_301():
    result = parse("DRB1*13:301")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:301") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_302():
    result = parse("DRB1*13:302")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:302") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_31():
    result = parse("DRB1*13:31")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_32():
    result = parse("DRB1*13:32")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_33_01():
    result = parse("DRB1*13:33:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:33:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:33:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_33_02():
    result = parse("DRB1*13:33:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:33:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:33:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_33_03():
    result = parse("DRB1*13:33:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:33:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:33:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_34():
    result = parse("DRB1*13:34")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_35():
    result = parse("DRB1*13:35")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_36():
    result = parse("DRB1*13:36")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_37():
    result = parse("DRB1*13:37")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_38():
    result = parse("DRB1*13:38")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_39():
    result = parse("DRB1*13:39")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_40():
    result = parse("DRB1*13:40")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_41():
    result = parse("DRB1*13:41")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_42_01():
    result = parse("DRB1*13:42:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:42:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:42:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_42_02():
    result = parse("DRB1*13:42:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:42:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:42:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_43():
    result = parse("DRB1*13:43")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_44():
    result = parse("DRB1*13:44")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_45():
    result = parse("DRB1*13:45")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_46():
    result = parse("DRB1*13:46")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_47():
    result = parse("DRB1*13:47")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_48():
    result = parse("DRB1*13:48")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_49():
    result = parse("DRB1*13:49")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_50_01():
    result = parse("DRB1*13:50:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:50:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:50:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_50_02():
    result = parse("DRB1*13:50:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:50:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:50:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_50_03():
    result = parse("DRB1*13:50:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:50:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:50:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_51():
    result = parse("DRB1*13:51")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_52():
    result = parse("DRB1*13:52")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_53():
    result = parse("DRB1*13:53")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_54():
    result = parse("DRB1*13:54")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_55():
    result = parse("DRB1*13:55")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_56():
    result = parse("DRB1*13:56")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_57():
    result = parse("DRB1*13:57")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_58():
    result = parse("DRB1*13:58")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_59():
    result = parse("DRB1*13:59")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_60():
    result = parse("DRB1*13:60")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_61_01():
    result = parse("DRB1*13:61:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:61:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:61:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_61_02():
    result = parse("DRB1*13:61:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:61:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:61:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_62():
    result = parse("DRB1*13:62")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_63():
    result = parse("DRB1*13:63")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_64():
    result = parse("DRB1*13:64")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_65():
    result = parse("DRB1*13:65")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_66_01():
    result = parse("DRB1*13:66:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:66:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:66:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_66_02():
    result = parse("DRB1*13:66:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:66:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:66:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_67():
    result = parse("DRB1*13:67")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_68():
    result = parse("DRB1*13:68")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_69():
    result = parse("DRB1*13:69")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_70():
    result = parse("DRB1*13:70")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_71():
    result = parse("DRB1*13:71")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_72():
    result = parse("DRB1*13:72")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_73():
    result = parse("DRB1*13:73")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_74():
    result = parse("DRB1*13:74")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_75():
    result = parse("DRB1*13:75")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_76():
    result = parse("DRB1*13:76")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_77():
    result = parse("DRB1*13:77")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_78():
    result = parse("DRB1*13:78")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_79():
    result = parse("DRB1*13:79")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_80():
    result = parse("DRB1*13:80")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_81():
    result = parse("DRB1*13:81")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_82():
    result = parse("DRB1*13:82")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_83():
    result = parse("DRB1*13:83")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_84():
    result = parse("DRB1*13:84")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_85():
    result = parse("DRB1*13:85")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_86():
    result = parse("DRB1*13:86")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_87():
    result = parse("DRB1*13:87")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_88():
    result = parse("DRB1*13:88")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_89_01():
    result = parse("DRB1*13:89:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:89:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:89:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_89_02():
    result = parse("DRB1*13:89:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:89:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:89:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_90():
    result = parse("DRB1*13:90")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_91():
    result = parse("DRB1*13:91")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_92():
    result = parse("DRB1*13:92")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_93():
    result = parse("DRB1*13:93")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_94_01():
    result = parse("DRB1*13:94:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:94:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:94:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_94_02():
    result = parse("DRB1*13:94:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:94:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:94:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_95():
    result = parse("DRB1*13:95")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_96_01():
    result = parse("DRB1*13:96:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:96:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:96:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_96_02():
    result = parse("DRB1*13:96:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:96:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:96:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_97_01():
    result = parse("DRB1*13:97:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:97:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:97:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_97_02():
    result = parse("DRB1*13:97:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*13:97:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*13:97:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_98():
    result = parse("DRB1*13:98")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_13_99():
    result = parse("DRB1*13:99")
    assert result.__class__ is Allele, f'Expected parse("DRB1*13:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*13:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_01_01():
    result = parse("DRB1*14:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_01_02():
    result = parse("DRB1*14:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_01_03():
    result = parse("DRB1*14:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_01_04():
    result = parse("DRB1*14:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_01_05():
    result = parse("DRB1*14:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_02_01_01():
    result = parse("DRB1*14:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*14:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_02_01_02():
    result = parse("DRB1*14:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*14:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_02_02():
    result = parse("DRB1*14:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_02_03():
    result = parse("DRB1*14:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_02_04():
    result = parse("DRB1*14:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_02_05():
    result = parse("DRB1*14:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_02_06():
    result = parse("DRB1*14:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_02_07():
    result = parse("DRB1*14:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_02_08():
    result = parse("DRB1*14:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_02_09():
    result = parse("DRB1*14:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_03_01():
    result = parse("DRB1*14:03:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:03:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:03:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_03_02():
    result = parse("DRB1*14:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_04_01_01():
    result = parse("DRB1*14:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*14:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_04_01_02():
    result = parse("DRB1*14:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*14:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_04_02():
    result = parse("DRB1*14:04:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:04:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_04_03():
    result = parse("DRB1*14:04:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:04:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_04_04():
    result = parse("DRB1*14:04:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:04:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:04:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_04_05():
    result = parse("DRB1*14:04:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:04:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:04:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_04_06():
    result = parse("DRB1*14:04:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:04:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:04:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_04_07():
    result = parse("DRB1*14:04:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:04:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:04:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_05_01_01():
    result = parse("DRB1*14:05:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:05:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*14:05:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_05_01_02():
    result = parse("DRB1*14:05:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:05:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*14:05:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_05_02():
    result = parse("DRB1*14:05:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:05:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_05_03():
    result = parse("DRB1*14:05:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:05:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:05:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_05_04():
    result = parse("DRB1*14:05:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:05:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:05:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_05_05():
    result = parse("DRB1*14:05:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:05:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:05:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_06_01():
    result = parse("DRB1*14:06:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:06:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_06_02():
    result = parse("DRB1*14:06:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:06:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_06_03():
    result = parse("DRB1*14:06:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:06:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:06:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_06_04():
    result = parse("DRB1*14:06:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:06:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:06:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_07_01():
    result = parse("DRB1*14:07:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:07:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_07_02():
    result = parse("DRB1*14:07:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:07:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_08():
    result = parse("DRB1*14:08")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_09():
    result = parse("DRB1*14:09")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_10():
    result = parse("DRB1*14:10")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_100():
    result = parse("DRB1*14:100")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_101():
    result = parse("DRB1*14:101")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_102():
    result = parse("DRB1*14:102")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_103():
    result = parse("DRB1*14:103")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_104():
    result = parse("DRB1*14:104")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_105():
    result = parse("DRB1*14:105")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_106():
    result = parse("DRB1*14:106")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_107():
    result = parse("DRB1*14:107")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_108():
    result = parse("DRB1*14:108")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_109():
    result = parse("DRB1*14:109")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_11():
    result = parse("DRB1*14:11")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_110():
    result = parse("DRB1*14:110")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_111():
    result = parse("DRB1*14:111")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_112():
    result = parse("DRB1*14:112")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_113():
    result = parse("DRB1*14:113")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_114():
    result = parse("DRB1*14:114")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_115():
    result = parse("DRB1*14:115")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:115") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_116():
    result = parse("DRB1*14:116")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_117():
    result = parse("DRB1*14:117")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_118():
    result = parse("DRB1*14:118")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:118") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_119():
    result = parse("DRB1*14:119")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:119") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_120():
    result = parse("DRB1*14:120")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:120") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_121():
    result = parse("DRB1*14:121")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:121") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_122():
    result = parse("DRB1*14:122")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:122") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_123():
    result = parse("DRB1*14:123")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:123") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_124():
    result = parse("DRB1*14:124")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:124") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_125():
    result = parse("DRB1*14:125")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:125") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_126_01():
    result = parse("DRB1*14:126:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:126:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:126:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_126_02():
    result = parse("DRB1*14:126:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:126:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:126:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_127_01():
    result = parse("DRB1*14:127:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:127:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:127:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_127_02():
    result = parse("DRB1*14:127:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:127:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:127:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_128():
    result = parse("DRB1*14:128")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:128") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_129():
    result = parse("DRB1*14:129")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:129") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_12_01():
    result = parse("DRB1*14:12:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:12:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:12:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_12_02():
    result = parse("DRB1*14:12:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:12:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:12:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_13():
    result = parse("DRB1*14:13")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_130():
    result = parse("DRB1*14:130")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:130") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_131():
    result = parse("DRB1*14:131")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:131") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_132():
    result = parse("DRB1*14:132")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:132") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_133():
    result = parse("DRB1*14:133")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:133") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_134():
    result = parse("DRB1*14:134")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:134") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_135():
    result = parse("DRB1*14:135")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:135") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_136():
    result = parse("DRB1*14:136")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:136") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_137N():
    result = parse("DRB1*14:137N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:137N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:137N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_138():
    result = parse("DRB1*14:138")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:138") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_139():
    result = parse("DRB1*14:139")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:139") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_14():
    result = parse("DRB1*14:14")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_140():
    result = parse("DRB1*14:140")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:140") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_141():
    result = parse("DRB1*14:141")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:141") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_142():
    result = parse("DRB1*14:142")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:142") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_143():
    result = parse("DRB1*14:143")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:143") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_144():
    result = parse("DRB1*14:144")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:144") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_145():
    result = parse("DRB1*14:145")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:145") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_146():
    result = parse("DRB1*14:146")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:146") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_147():
    result = parse("DRB1*14:147")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:147") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_148():
    result = parse("DRB1*14:148")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:148") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_149():
    result = parse("DRB1*14:149")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:149") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_15():
    result = parse("DRB1*14:15")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_150():
    result = parse("DRB1*14:150")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:150") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_151():
    result = parse("DRB1*14:151")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:151") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_152N():
    result = parse("DRB1*14:152N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:152N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:152N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_153():
    result = parse("DRB1*14:153")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:153") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_154():
    result = parse("DRB1*14:154")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:154") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_155():
    result = parse("DRB1*14:155")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:155") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_156():
    result = parse("DRB1*14:156")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:156") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_157():
    result = parse("DRB1*14:157")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:157") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_158():
    result = parse("DRB1*14:158")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:158") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_159():
    result = parse("DRB1*14:159")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:159") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_16():
    result = parse("DRB1*14:16")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_160():
    result = parse("DRB1*14:160")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:160") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_161():
    result = parse("DRB1*14:161")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:161") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_162():
    result = parse("DRB1*14:162")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:162") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_163():
    result = parse("DRB1*14:163")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:163") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_164():
    result = parse("DRB1*14:164")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:164") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_165():
    result = parse("DRB1*14:165")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:165") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_166N():
    result = parse("DRB1*14:166N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:166N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:166N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_167():
    result = parse("DRB1*14:167")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:167") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_168():
    result = parse("DRB1*14:168")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:168") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_169():
    result = parse("DRB1*14:169")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:169") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_17():
    result = parse("DRB1*14:17")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_170():
    result = parse("DRB1*14:170")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:170") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_171():
    result = parse("DRB1*14:171")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:171") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_172():
    result = parse("DRB1*14:172")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:172") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_173():
    result = parse("DRB1*14:173")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:173") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_174():
    result = parse("DRB1*14:174")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:174") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_175():
    result = parse("DRB1*14:175")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:175") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_176():
    result = parse("DRB1*14:176")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:176") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_177():
    result = parse("DRB1*14:177")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:177") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_178():
    result = parse("DRB1*14:178")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:178") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_179():
    result = parse("DRB1*14:179")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:179") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_18():
    result = parse("DRB1*14:18")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_180():
    result = parse("DRB1*14:180")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:180") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_181():
    result = parse("DRB1*14:181")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:181") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_182():
    result = parse("DRB1*14:182")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:182") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_183():
    result = parse("DRB1*14:183")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:183") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_184():
    result = parse("DRB1*14:184")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:184") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_185():
    result = parse("DRB1*14:185")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:185") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_186():
    result = parse("DRB1*14:186")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:186") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_187():
    result = parse("DRB1*14:187")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:187") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_188N():
    result = parse("DRB1*14:188N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:188N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:188N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_189():
    result = parse("DRB1*14:189")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:189") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_19():
    result = parse("DRB1*14:19")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_190():
    result = parse("DRB1*14:190")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:190") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_191():
    result = parse("DRB1*14:191")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:191") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_192():
    result = parse("DRB1*14:192")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:192") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_193():
    result = parse("DRB1*14:193")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:193") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_194():
    result = parse("DRB1*14:194")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:194") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_195N():
    result = parse("DRB1*14:195N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:195N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:195N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_196():
    result = parse("DRB1*14:196")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:196") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_197N():
    result = parse("DRB1*14:197N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:197N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:197N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_198():
    result = parse("DRB1*14:198")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:198") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_199():
    result = parse("DRB1*14:199")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:199") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_20():
    result = parse("DRB1*14:20")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_200():
    result = parse("DRB1*14:200")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:200") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_201():
    result = parse("DRB1*14:201")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:201") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_202():
    result = parse("DRB1*14:202")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:202") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_203():
    result = parse("DRB1*14:203")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:203") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_204():
    result = parse("DRB1*14:204")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:204") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_205():
    result = parse("DRB1*14:205")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:205") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_206():
    result = parse("DRB1*14:206")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:206") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_207():
    result = parse("DRB1*14:207")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:207") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_208():
    result = parse("DRB1*14:208")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:208") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_209():
    result = parse("DRB1*14:209")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:209") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_21():
    result = parse("DRB1*14:21")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_210Q():
    result = parse("DRB1*14:210Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:210Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:210Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_211():
    result = parse("DRB1*14:211")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:211") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_212():
    result = parse("DRB1*14:212")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:212") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_213():
    result = parse("DRB1*14:213")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:213") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_214():
    result = parse("DRB1*14:214")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:214") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_215():
    result = parse("DRB1*14:215")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:215") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_216():
    result = parse("DRB1*14:216")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:216") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_217():
    result = parse("DRB1*14:217")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:217") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_218():
    result = parse("DRB1*14:218")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:218") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_219():
    result = parse("DRB1*14:219")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:219") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_22():
    result = parse("DRB1*14:22")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_220():
    result = parse("DRB1*14:220")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:220") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_221():
    result = parse("DRB1*14:221")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:221") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_222N():
    result = parse("DRB1*14:222N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:222N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:222N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_223():
    result = parse("DRB1*14:223")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:223") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_224():
    result = parse("DRB1*14:224")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:224") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_23_01():
    result = parse("DRB1*14:23:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:23:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:23:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_23_02():
    result = parse("DRB1*14:23:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:23:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:23:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_23_03():
    result = parse("DRB1*14:23:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:23:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:23:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_23_04():
    result = parse("DRB1*14:23:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:23:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:23:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_24():
    result = parse("DRB1*14:24")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_25_01():
    result = parse("DRB1*14:25:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:25:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:25:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_25_02():
    result = parse("DRB1*14:25:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:25:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:25:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_26():
    result = parse("DRB1*14:26")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_27_01():
    result = parse("DRB1*14:27:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:27:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:27:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_27_02():
    result = parse("DRB1*14:27:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:27:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:27:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_28():
    result = parse("DRB1*14:28")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_29():
    result = parse("DRB1*14:29")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_30():
    result = parse("DRB1*14:30")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_31():
    result = parse("DRB1*14:31")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_32_01():
    result = parse("DRB1*14:32:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:32:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:32:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_32_02():
    result = parse("DRB1*14:32:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:32:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:32:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_32_03():
    result = parse("DRB1*14:32:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:32:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:32:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_33():
    result = parse("DRB1*14:33")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_34():
    result = parse("DRB1*14:34")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_35():
    result = parse("DRB1*14:35")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_36():
    result = parse("DRB1*14:36")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_37():
    result = parse("DRB1*14:37")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_38_01():
    result = parse("DRB1*14:38:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:38:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:38:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_38_02():
    result = parse("DRB1*14:38:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:38:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:38:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_39():
    result = parse("DRB1*14:39")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_40():
    result = parse("DRB1*14:40")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_41():
    result = parse("DRB1*14:41")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_42():
    result = parse("DRB1*14:42")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_43():
    result = parse("DRB1*14:43")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_44_01():
    result = parse("DRB1*14:44:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:44:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:44:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_44_02():
    result = parse("DRB1*14:44:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:44:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:44:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_44_03():
    result = parse("DRB1*14:44:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:44:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:44:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_45():
    result = parse("DRB1*14:45")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_46():
    result = parse("DRB1*14:46")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_47():
    result = parse("DRB1*14:47")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_48():
    result = parse("DRB1*14:48")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_49():
    result = parse("DRB1*14:49")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_50():
    result = parse("DRB1*14:50")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_51():
    result = parse("DRB1*14:51")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_52():
    result = parse("DRB1*14:52")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_53():
    result = parse("DRB1*14:53")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_54_01_01():
    result = parse("DRB1*14:54:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:54:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*14:54:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_54_01_02():
    result = parse("DRB1*14:54:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:54:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*14:54:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_54_01_03():
    result = parse("DRB1*14:54:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:54:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*14:54:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_54_01_04():
    result = parse("DRB1*14:54:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:54:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*14:54:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_54_01_05():
    result = parse("DRB1*14:54:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:54:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*14:54:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_54_02():
    result = parse("DRB1*14:54:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:54:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:54:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_54_03():
    result = parse("DRB1*14:54:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:54:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:54:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_54_04():
    result = parse("DRB1*14:54:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:54:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:54:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_54_05():
    result = parse("DRB1*14:54:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:54:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:54:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_54_06():
    result = parse("DRB1*14:54:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:54:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:54:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_54_07():
    result = parse("DRB1*14:54:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:54:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:54:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_54_08():
    result = parse("DRB1*14:54:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:54:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:54:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_54_09():
    result = parse("DRB1*14:54:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:54:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:54:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_54_10():
    result = parse("DRB1*14:54:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:54:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:54:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_55():
    result = parse("DRB1*14:55")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_56():
    result = parse("DRB1*14:56")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_57():
    result = parse("DRB1*14:57")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_58():
    result = parse("DRB1*14:58")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_59():
    result = parse("DRB1*14:59")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_60():
    result = parse("DRB1*14:60")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_61():
    result = parse("DRB1*14:61")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_62():
    result = parse("DRB1*14:62")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_63():
    result = parse("DRB1*14:63")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_64():
    result = parse("DRB1*14:64")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_65():
    result = parse("DRB1*14:65")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_67():
    result = parse("DRB1*14:67")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_68_01():
    result = parse("DRB1*14:68:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:68:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:68:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_68_02():
    result = parse("DRB1*14:68:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:68:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*14:68:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_69():
    result = parse("DRB1*14:69")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_70():
    result = parse("DRB1*14:70")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_71():
    result = parse("DRB1*14:71")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_72():
    result = parse("DRB1*14:72")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_73():
    result = parse("DRB1*14:73")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_74():
    result = parse("DRB1*14:74")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_75():
    result = parse("DRB1*14:75")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_76():
    result = parse("DRB1*14:76")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_77():
    result = parse("DRB1*14:77")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_78():
    result = parse("DRB1*14:78")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_79():
    result = parse("DRB1*14:79")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_80():
    result = parse("DRB1*14:80")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_81():
    result = parse("DRB1*14:81")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_82():
    result = parse("DRB1*14:82")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_83():
    result = parse("DRB1*14:83")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_84():
    result = parse("DRB1*14:84")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_85():
    result = parse("DRB1*14:85")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_86():
    result = parse("DRB1*14:86")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_87():
    result = parse("DRB1*14:87")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_88():
    result = parse("DRB1*14:88")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_89():
    result = parse("DRB1*14:89")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_90():
    result = parse("DRB1*14:90")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_91():
    result = parse("DRB1*14:91")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_92N():
    result = parse("DRB1*14:92N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*14:92N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:92N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_93():
    result = parse("DRB1*14:93")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_94():
    result = parse("DRB1*14:94")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_95():
    result = parse("DRB1*14:95")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_96():
    result = parse("DRB1*14:96")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_97():
    result = parse("DRB1*14:97")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_98():
    result = parse("DRB1*14:98")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_14_99():
    result = parse("DRB1*14:99")
    assert result.__class__ is Allele, f'Expected parse("DRB1*14:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*14:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_01_01():
    result = parse("DRB1*15:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*15:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_01_02():
    result = parse("DRB1*15:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*15:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_01_03():
    result = parse("DRB1*15:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*15:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_01_04():
    result = parse("DRB1*15:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*15:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_01_05():
    result = parse("DRB1*15:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*15:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_02():
    result = parse("DRB1*15:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_03():
    result = parse("DRB1*15:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_04():
    result = parse("DRB1*15:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_05():
    result = parse("DRB1*15:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_06():
    result = parse("DRB1*15:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_07():
    result = parse("DRB1*15:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_08():
    result = parse("DRB1*15:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_09():
    result = parse("DRB1*15:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_10():
    result = parse("DRB1*15:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_11():
    result = parse("DRB1*15:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_12():
    result = parse("DRB1*15:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_13():
    result = parse("DRB1*15:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_14():
    result = parse("DRB1*15:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_15():
    result = parse("DRB1*15:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_16():
    result = parse("DRB1*15:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_17():
    result = parse("DRB1*15:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_18():
    result = parse("DRB1*15:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_19():
    result = parse("DRB1*15:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_20():
    result = parse("DRB1*15:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_21():
    result = parse("DRB1*15:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_22():
    result = parse("DRB1*15:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_23():
    result = parse("DRB1*15:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_24():
    result = parse("DRB1*15:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_25():
    result = parse("DRB1*15:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_26():
    result = parse("DRB1*15:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_27():
    result = parse("DRB1*15:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_28():
    result = parse("DRB1*15:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_29():
    result = parse("DRB1*15:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_30():
    result = parse("DRB1*15:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_31():
    result = parse("DRB1*15:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_32():
    result = parse("DRB1*15:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_33():
    result = parse("DRB1*15:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_34():
    result = parse("DRB1*15:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_35():
    result = parse("DRB1*15:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_36():
    result = parse("DRB1*15:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_37():
    result = parse("DRB1*15:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_38():
    result = parse("DRB1*15:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_39():
    result = parse("DRB1*15:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_40():
    result = parse("DRB1*15:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_41():
    result = parse("DRB1*15:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_01_42():
    result = parse("DRB1*15:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_01_01():
    result = parse("DRB1*15:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*15:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_01_02():
    result = parse("DRB1*15:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*15:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_01_03():
    result = parse("DRB1*15:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*15:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_01_04():
    result = parse("DRB1*15:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*15:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_01_05():
    result = parse("DRB1*15:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*15:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_02():
    result = parse("DRB1*15:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_03():
    result = parse("DRB1*15:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_04():
    result = parse("DRB1*15:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_05():
    result = parse("DRB1*15:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_06():
    result = parse("DRB1*15:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_07():
    result = parse("DRB1*15:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_08():
    result = parse("DRB1*15:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_09():
    result = parse("DRB1*15:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_10():
    result = parse("DRB1*15:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_11():
    result = parse("DRB1*15:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_12():
    result = parse("DRB1*15:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_13():
    result = parse("DRB1*15:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_14():
    result = parse("DRB1*15:02:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_15():
    result = parse("DRB1*15:02:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_16():
    result = parse("DRB1*15:02:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_17():
    result = parse("DRB1*15:02:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_18():
    result = parse("DRB1*15:02:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_02_19():
    result = parse("DRB1*15:02:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:02:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_03_01_01():
    result = parse("DRB1*15:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*15:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_03_01_02():
    result = parse("DRB1*15:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*15:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_03_01_03():
    result = parse("DRB1*15:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*15:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_03_02():
    result = parse("DRB1*15:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_03_03():
    result = parse("DRB1*15:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_03_04():
    result = parse("DRB1*15:03:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:03:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_03_05():
    result = parse("DRB1*15:03:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:03:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_04():
    result = parse("DRB1*15:04")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_05():
    result = parse("DRB1*15:05")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_06_01():
    result = parse("DRB1*15:06:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:06:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_06_02():
    result = parse("DRB1*15:06:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:06:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_06_03():
    result = parse("DRB1*15:06:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:06:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:06:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_06_04():
    result = parse("DRB1*15:06:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:06:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:06:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_07_01():
    result = parse("DRB1*15:07:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:07:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_07_02():
    result = parse("DRB1*15:07:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:07:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_07_03():
    result = parse("DRB1*15:07:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:07:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:07:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_08():
    result = parse("DRB1*15:08")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_09():
    result = parse("DRB1*15:09")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_10():
    result = parse("DRB1*15:10")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_100():
    result = parse("DRB1*15:100")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_101():
    result = parse("DRB1*15:101")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_102():
    result = parse("DRB1*15:102")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_103():
    result = parse("DRB1*15:103")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_104_01():
    result = parse("DRB1*15:104:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:104:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:104:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_104_02():
    result = parse("DRB1*15:104:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:104:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:104:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_104_03():
    result = parse("DRB1*15:104:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:104:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:104:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_105_01():
    result = parse("DRB1*15:105:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:105:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:105:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_105_02():
    result = parse("DRB1*15:105:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:105:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:105:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_106():
    result = parse("DRB1*15:106")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_107():
    result = parse("DRB1*15:107")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_108():
    result = parse("DRB1*15:108")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_109():
    result = parse("DRB1*15:109")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_110():
    result = parse("DRB1*15:110")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_111():
    result = parse("DRB1*15:111")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_112():
    result = parse("DRB1*15:112")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_113N():
    result = parse("DRB1*15:113N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:113N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:113N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_114():
    result = parse("DRB1*15:114")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_115N():
    result = parse("DRB1*15:115N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:115N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:115N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_116():
    result = parse("DRB1*15:116")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_117():
    result = parse("DRB1*15:117")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_118():
    result = parse("DRB1*15:118")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:118") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_119():
    result = parse("DRB1*15:119")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:119") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_11_01():
    result = parse("DRB1*15:11:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:11:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:11:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_11_02():
    result = parse("DRB1*15:11:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:11:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:11:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_12():
    result = parse("DRB1*15:12")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_120():
    result = parse("DRB1*15:120")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:120") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_121():
    result = parse("DRB1*15:121")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:121") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_122():
    result = parse("DRB1*15:122")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:122") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_123():
    result = parse("DRB1*15:123")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:123") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_124():
    result = parse("DRB1*15:124")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:124") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_125():
    result = parse("DRB1*15:125")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:125") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_126():
    result = parse("DRB1*15:126")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:126") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_127():
    result = parse("DRB1*15:127")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:127") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_128():
    result = parse("DRB1*15:128")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:128") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_129N():
    result = parse("DRB1*15:129N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:129N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:129N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_13():
    result = parse("DRB1*15:13")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_130():
    result = parse("DRB1*15:130")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:130") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_131():
    result = parse("DRB1*15:131")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:131") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_132():
    result = parse("DRB1*15:132")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:132") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_133():
    result = parse("DRB1*15:133")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:133") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_134N():
    result = parse("DRB1*15:134N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:134N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:134N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_135():
    result = parse("DRB1*15:135")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:135") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_136():
    result = parse("DRB1*15:136")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:136") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_137N():
    result = parse("DRB1*15:137N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:137N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:137N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_138N():
    result = parse("DRB1*15:138N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:138N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:138N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_139():
    result = parse("DRB1*15:139")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:139") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_14():
    result = parse("DRB1*15:14")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_140():
    result = parse("DRB1*15:140")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:140") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_141():
    result = parse("DRB1*15:141")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:141") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_142():
    result = parse("DRB1*15:142")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:142") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_143():
    result = parse("DRB1*15:143")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:143") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_144():
    result = parse("DRB1*15:144")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:144") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_145():
    result = parse("DRB1*15:145")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:145") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_146():
    result = parse("DRB1*15:146")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:146") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_147():
    result = parse("DRB1*15:147")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:147") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_148N():
    result = parse("DRB1*15:148N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:148N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:148N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_149():
    result = parse("DRB1*15:149")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:149") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_150():
    result = parse("DRB1*15:150")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:150") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_151():
    result = parse("DRB1*15:151")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:151") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_152():
    result = parse("DRB1*15:152")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:152") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_153():
    result = parse("DRB1*15:153")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:153") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_154N():
    result = parse("DRB1*15:154N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:154N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:154N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_155():
    result = parse("DRB1*15:155")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:155") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_156():
    result = parse("DRB1*15:156")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:156") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_157():
    result = parse("DRB1*15:157")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:157") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_158():
    result = parse("DRB1*15:158")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:158") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_159N():
    result = parse("DRB1*15:159N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:159N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:159N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_15_01():
    result = parse("DRB1*15:15:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:15:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:15:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_15_02():
    result = parse("DRB1*15:15:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:15:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:15:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_15_03():
    result = parse("DRB1*15:15:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:15:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:15:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_16():
    result = parse("DRB1*15:16")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_160():
    result = parse("DRB1*15:160")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:160") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_161():
    result = parse("DRB1*15:161")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:161") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_162():
    result = parse("DRB1*15:162")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:162") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_163N():
    result = parse("DRB1*15:163N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:163N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:163N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_164Q():
    result = parse("DRB1*15:164Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:164Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:164Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_165():
    result = parse("DRB1*15:165")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:165") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_166():
    result = parse("DRB1*15:166")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:166") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_167():
    result = parse("DRB1*15:167")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:167") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_168():
    result = parse("DRB1*15:168")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:168") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_169():
    result = parse("DRB1*15:169")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:169") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_170():
    result = parse("DRB1*15:170")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:170") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_171_01():
    result = parse("DRB1*15:171:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:171:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:171:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_171_02():
    result = parse("DRB1*15:171:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:171:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:171:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_172():
    result = parse("DRB1*15:172")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:172") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_173():
    result = parse("DRB1*15:173")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:173") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_174():
    result = parse("DRB1*15:174")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:174") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_175():
    result = parse("DRB1*15:175")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:175") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_176N():
    result = parse("DRB1*15:176N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:176N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:176N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_177():
    result = parse("DRB1*15:177")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:177") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_178():
    result = parse("DRB1*15:178")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:178") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_179():
    result = parse("DRB1*15:179")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:179") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_17N():
    result = parse("DRB1*15:17N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:17N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:17N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_18():
    result = parse("DRB1*15:18")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_180N():
    result = parse("DRB1*15:180N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:180N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:180N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_181():
    result = parse("DRB1*15:181")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:181") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_182():
    result = parse("DRB1*15:182")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:182") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_183N():
    result = parse("DRB1*15:183N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:183N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:183N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_184():
    result = parse("DRB1*15:184")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:184") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_185():
    result = parse("DRB1*15:185")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:185") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_186():
    result = parse("DRB1*15:186")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:186") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_19():
    result = parse("DRB1*15:19")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_20():
    result = parse("DRB1*15:20")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_21():
    result = parse("DRB1*15:21")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_22():
    result = parse("DRB1*15:22")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_23():
    result = parse("DRB1*15:23")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_24():
    result = parse("DRB1*15:24")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_25():
    result = parse("DRB1*15:25")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_26():
    result = parse("DRB1*15:26")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_27():
    result = parse("DRB1*15:27")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_28():
    result = parse("DRB1*15:28")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_29():
    result = parse("DRB1*15:29")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_30():
    result = parse("DRB1*15:30")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_31_01():
    result = parse("DRB1*15:31:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:31:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:31:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_31_02():
    result = parse("DRB1*15:31:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:31:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:31:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_32():
    result = parse("DRB1*15:32")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_33():
    result = parse("DRB1*15:33")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_34():
    result = parse("DRB1*15:34")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_35():
    result = parse("DRB1*15:35")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_36():
    result = parse("DRB1*15:36")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_37_01():
    result = parse("DRB1*15:37:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:37:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:37:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_37_02():
    result = parse("DRB1*15:37:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:37:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:37:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_38():
    result = parse("DRB1*15:38")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_39():
    result = parse("DRB1*15:39")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_40():
    result = parse("DRB1*15:40")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_41():
    result = parse("DRB1*15:41")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_42():
    result = parse("DRB1*15:42")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_43():
    result = parse("DRB1*15:43")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_44():
    result = parse("DRB1*15:44")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_45():
    result = parse("DRB1*15:45")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_46():
    result = parse("DRB1*15:46")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_47():
    result = parse("DRB1*15:47")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_48():
    result = parse("DRB1*15:48")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_49():
    result = parse("DRB1*15:49")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_50N():
    result = parse("DRB1*15:50N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:50N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:50N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_51():
    result = parse("DRB1*15:51")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_52():
    result = parse("DRB1*15:52")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_53():
    result = parse("DRB1*15:53")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_54():
    result = parse("DRB1*15:54")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_55():
    result = parse("DRB1*15:55")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_56():
    result = parse("DRB1*15:56")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_57():
    result = parse("DRB1*15:57")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_58():
    result = parse("DRB1*15:58")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_59():
    result = parse("DRB1*15:59")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_60():
    result = parse("DRB1*15:60")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_61():
    result = parse("DRB1*15:61")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_62():
    result = parse("DRB1*15:62")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_63():
    result = parse("DRB1*15:63")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_64():
    result = parse("DRB1*15:64")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_65():
    result = parse("DRB1*15:65")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_66_01():
    result = parse("DRB1*15:66:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:66:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:66:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_66_02():
    result = parse("DRB1*15:66:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:66:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*15:66:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_67():
    result = parse("DRB1*15:67")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_68():
    result = parse("DRB1*15:68")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_69():
    result = parse("DRB1*15:69")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_70():
    result = parse("DRB1*15:70")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_71():
    result = parse("DRB1*15:71")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_72():
    result = parse("DRB1*15:72")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_73():
    result = parse("DRB1*15:73")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_74():
    result = parse("DRB1*15:74")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_75():
    result = parse("DRB1*15:75")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_76():
    result = parse("DRB1*15:76")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_77():
    result = parse("DRB1*15:77")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_78():
    result = parse("DRB1*15:78")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_79():
    result = parse("DRB1*15:79")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_80N():
    result = parse("DRB1*15:80N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*15:80N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:80N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_81():
    result = parse("DRB1*15:81")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_82():
    result = parse("DRB1*15:82")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_83():
    result = parse("DRB1*15:83")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_84():
    result = parse("DRB1*15:84")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_85():
    result = parse("DRB1*15:85")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_86():
    result = parse("DRB1*15:86")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_87():
    result = parse("DRB1*15:87")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_88():
    result = parse("DRB1*15:88")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_89():
    result = parse("DRB1*15:89")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_90():
    result = parse("DRB1*15:90")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_91():
    result = parse("DRB1*15:91")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_92():
    result = parse("DRB1*15:92")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_93():
    result = parse("DRB1*15:93")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_94():
    result = parse("DRB1*15:94")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_95():
    result = parse("DRB1*15:95")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_96():
    result = parse("DRB1*15:96")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_97():
    result = parse("DRB1*15:97")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_98():
    result = parse("DRB1*15:98")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_15_99():
    result = parse("DRB1*15:99")
    assert result.__class__ is Allele, f'Expected parse("DRB1*15:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*15:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_01_01():
    result = parse("DRB1*16:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_01_02():
    result = parse("DRB1*16:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_01_03():
    result = parse("DRB1*16:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_01_04():
    result = parse("DRB1*16:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_01_05():
    result = parse("DRB1*16:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_01_06():
    result = parse("DRB1*16:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_01_07():
    result = parse("DRB1*16:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_01_08():
    result = parse("DRB1*16:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_01_09():
    result = parse("DRB1*16:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_01_10():
    result = parse("DRB1*16:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_01_11():
    result = parse("DRB1*16:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_01_12():
    result = parse("DRB1*16:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_01_13():
    result = parse("DRB1*16:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_01_14():
    result = parse("DRB1*16:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_01_15():
    result = parse("DRB1*16:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_01_16():
    result = parse("DRB1*16:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_02_01_01():
    result = parse("DRB1*16:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*16:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_02_01_02():
    result = parse("DRB1*16:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*16:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_02_01_03():
    result = parse("DRB1*16:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*16:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_02_01_04():
    result = parse("DRB1*16:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB1*16:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_02_02():
    result = parse("DRB1*16:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_02_03():
    result = parse("DRB1*16:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_02_04():
    result = parse("DRB1*16:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_02_05():
    result = parse("DRB1*16:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_02_06():
    result = parse("DRB1*16:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_02_07():
    result = parse("DRB1*16:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_02_08():
    result = parse("DRB1*16:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_02_09():
    result = parse("DRB1*16:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_03():
    result = parse("DRB1*16:03")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_04_01():
    result = parse("DRB1*16:04:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:04:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_04_02():
    result = parse("DRB1*16:04:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:04:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_05_01():
    result = parse("DRB1*16:05:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:05:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_05_02():
    result = parse("DRB1*16:05:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:05:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_07():
    result = parse("DRB1*16:07")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_08():
    result = parse("DRB1*16:08")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_09_01():
    result = parse("DRB1*16:09:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:09:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:09:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_09_02():
    result = parse("DRB1*16:09:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:09:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:09:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_10_01():
    result = parse("DRB1*16:10:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:10:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:10:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_10_02():
    result = parse("DRB1*16:10:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:10:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:10:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_11():
    result = parse("DRB1*16:11")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_12():
    result = parse("DRB1*16:12")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_13N():
    result = parse("DRB1*16:13N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:13N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:13N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_14():
    result = parse("DRB1*16:14")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_15():
    result = parse("DRB1*16:15")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_16():
    result = parse("DRB1*16:16")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_17():
    result = parse("DRB1*16:17")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_18():
    result = parse("DRB1*16:18")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_19():
    result = parse("DRB1*16:19")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_20():
    result = parse("DRB1*16:20")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_21N():
    result = parse("DRB1*16:21N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:21N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:21N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_22():
    result = parse("DRB1*16:22")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_23():
    result = parse("DRB1*16:23")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_24():
    result = parse("DRB1*16:24")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_25():
    result = parse("DRB1*16:25")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_26():
    result = parse("DRB1*16:26")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_27():
    result = parse("DRB1*16:27")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_28():
    result = parse("DRB1*16:28")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_29():
    result = parse("DRB1*16:29")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_30():
    result = parse("DRB1*16:30")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_31():
    result = parse("DRB1*16:31")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_32():
    result = parse("DRB1*16:32")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_33():
    result = parse("DRB1*16:33")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_34():
    result = parse("DRB1*16:34")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_35():
    result = parse("DRB1*16:35")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_36():
    result = parse("DRB1*16:36")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_37():
    result = parse("DRB1*16:37")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_38_01():
    result = parse("DRB1*16:38:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:38:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:38:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_38_02():
    result = parse("DRB1*16:38:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:38:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB1*16:38:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_39():
    result = parse("DRB1*16:39")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_40():
    result = parse("DRB1*16:40")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_41N():
    result = parse("DRB1*16:41N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:41N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:41N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_42():
    result = parse("DRB1*16:42")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_43():
    result = parse("DRB1*16:43")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_44():
    result = parse("DRB1*16:44")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_45():
    result = parse("DRB1*16:45")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_46():
    result = parse("DRB1*16:46")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_47():
    result = parse("DRB1*16:47")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_48():
    result = parse("DRB1*16:48")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_49():
    result = parse("DRB1*16:49")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_50():
    result = parse("DRB1*16:50")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_51():
    result = parse("DRB1*16:51")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_52():
    result = parse("DRB1*16:52")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_53():
    result = parse("DRB1*16:53")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_54():
    result = parse("DRB1*16:54")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_55N():
    result = parse("DRB1*16:55N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:55N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:55N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_56():
    result = parse("DRB1*16:56")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_57():
    result = parse("DRB1*16:57")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_58():
    result = parse("DRB1*16:58")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_59Q():
    result = parse("DRB1*16:59Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:59Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:59Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_60():
    result = parse("DRB1*16:60")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_61():
    result = parse("DRB1*16:61")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_62N():
    result = parse("DRB1*16:62N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:62N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:62N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_63N():
    result = parse("DRB1*16:63N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB1*16:63N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:63N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_64():
    result = parse("DRB1*16:64")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB1_16_65():
    result = parse("DRB1*16:65")
    assert result.__class__ is Allele, f'Expected parse("DRB1*16:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB1*16:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_02_01():
    result = parse("DRB3*01:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*01:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_02_02():
    result = parse("DRB3*01:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*01:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_02_03():
    result = parse("DRB3*01:01:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*01:01:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_02_04():
    result = parse("DRB3*01:01:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*01:01:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_02_05():
    result = parse("DRB3*01:01:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*01:01:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_02_06():
    result = parse("DRB3*01:01:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*01:01:02:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_03():
    result = parse("DRB3*01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*01:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_04():
    result = parse("DRB3*01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*01:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_05():
    result = parse("DRB3*01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*01:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_06():
    result = parse("DRB3*01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*01:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_07():
    result = parse("DRB3*01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*01:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_08():
    result = parse("DRB3*01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*01:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_09():
    result = parse("DRB3*01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*01:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_10():
    result = parse("DRB3*01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*01:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_11():
    result = parse("DRB3*01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*01:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_12():
    result = parse("DRB3*01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*01:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_13():
    result = parse("DRB3*01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*01:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_01_14():
    result = parse("DRB3*01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*01:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_02():
    result = parse("DRB3*01:02")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_03():
    result = parse("DRB3*01:03")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_04():
    result = parse("DRB3*01:04")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_05():
    result = parse("DRB3*01:05")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_06():
    result = parse("DRB3*01:06")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_07():
    result = parse("DRB3*01:07")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_08():
    result = parse("DRB3*01:08")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_09():
    result = parse("DRB3*01:09")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_10():
    result = parse("DRB3*01:10")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_11():
    result = parse("DRB3*01:11")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_12():
    result = parse("DRB3*01:12")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_13():
    result = parse("DRB3*01:13")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_14():
    result = parse("DRB3*01:14")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_15():
    result = parse("DRB3*01:15")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_16():
    result = parse("DRB3*01:16")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_17():
    result = parse("DRB3*01:17")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_18():
    result = parse("DRB3*01:18")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_19():
    result = parse("DRB3*01:19")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_20():
    result = parse("DRB3*01:20")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_21():
    result = parse("DRB3*01:21")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_22():
    result = parse("DRB3*01:22")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_23():
    result = parse("DRB3*01:23")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_24():
    result = parse("DRB3*01:24")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_25():
    result = parse("DRB3*01:25")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_26N():
    result = parse("DRB3*01:26N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:26N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:26N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_27():
    result = parse("DRB3*01:27")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_28():
    result = parse("DRB3*01:28")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_29():
    result = parse("DRB3*01:29")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_30():
    result = parse("DRB3*01:30")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_31():
    result = parse("DRB3*01:31")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_32():
    result = parse("DRB3*01:32")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_33():
    result = parse("DRB3*01:33")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_34():
    result = parse("DRB3*01:34")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_35():
    result = parse("DRB3*01:35")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_36():
    result = parse("DRB3*01:36")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_37():
    result = parse("DRB3*01:37")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_38():
    result = parse("DRB3*01:38")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_39():
    result = parse("DRB3*01:39")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_40_01N():
    result = parse("DRB3*01:40:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:40:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*01:40:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_40_02N():
    result = parse("DRB3*01:40:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:40:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*01:40:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_41():
    result = parse("DRB3*01:41")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_42():
    result = parse("DRB3*01:42")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_43():
    result = parse("DRB3*01:43")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_44():
    result = parse("DRB3*01:44")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_45():
    result = parse("DRB3*01:45")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_46():
    result = parse("DRB3*01:46")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_47():
    result = parse("DRB3*01:47")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_48():
    result = parse("DRB3*01:48")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_49():
    result = parse("DRB3*01:49")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_50():
    result = parse("DRB3*01:50")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_51():
    result = parse("DRB3*01:51")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_52():
    result = parse("DRB3*01:52")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_53():
    result = parse("DRB3*01:53")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_54():
    result = parse("DRB3*01:54")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_55():
    result = parse("DRB3*01:55")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_56():
    result = parse("DRB3*01:56")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_57():
    result = parse("DRB3*01:57")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_58():
    result = parse("DRB3*01:58")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_59():
    result = parse("DRB3*01:59")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_60():
    result = parse("DRB3*01:60")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_61():
    result = parse("DRB3*01:61")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_62_01_01():
    result = parse("DRB3*01:62:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:62:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*01:62:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_62_01_02():
    result = parse("DRB3*01:62:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:62:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*01:62:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_63():
    result = parse("DRB3*01:63")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_64():
    result = parse("DRB3*01:64")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_65():
    result = parse("DRB3*01:65")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_66():
    result = parse("DRB3*01:66")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_67():
    result = parse("DRB3*01:67")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_68():
    result = parse("DRB3*01:68")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_69():
    result = parse("DRB3*01:69")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_70():
    result = parse("DRB3*01:70")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_71():
    result = parse("DRB3*01:71")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_72():
    result = parse("DRB3*01:72")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_73N():
    result = parse("DRB3*01:73N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:73N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:73N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_74():
    result = parse("DRB3*01:74")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_75():
    result = parse("DRB3*01:75")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_76():
    result = parse("DRB3*01:76")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_77N():
    result = parse("DRB3*01:77N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:77N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:77N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_78():
    result = parse("DRB3*01:78")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_79():
    result = parse("DRB3*01:79")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_80():
    result = parse("DRB3*01:80")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_81N():
    result = parse("DRB3*01:81N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*01:81N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:81N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_82():
    result = parse("DRB3*01:82")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_83():
    result = parse("DRB3*01:83")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_84():
    result = parse("DRB3*01:84")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_85():
    result = parse("DRB3*01:85")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_01_86():
    result = parse("DRB3*01:86")
    assert result.__class__ is Allele, f'Expected parse("DRB3*01:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*01:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_01():
    result = parse("DRB3*02:01")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_01_01():
    result = parse("DRB3*02:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*02:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_01_02():
    result = parse("DRB3*02:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*02:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_01_03():
    result = parse("DRB3*02:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*02:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_01_04():
    result = parse("DRB3*02:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*02:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_01_05():
    result = parse("DRB3*02:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*02:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_01_06():
    result = parse("DRB3*02:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*02:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_01_07():
    result = parse("DRB3*02:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*02:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_01_08():
    result = parse("DRB3*02:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*02:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_01_09():
    result = parse("DRB3*02:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*02:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_01_10():
    result = parse("DRB3*02:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*02:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_01_11():
    result = parse("DRB3*02:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*02:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_01_12():
    result = parse("DRB3*02:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*02:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_01_13():
    result = parse("DRB3*02:02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*02:02:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_02():
    result = parse("DRB3*02:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_03():
    result = parse("DRB3*02:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_04():
    result = parse("DRB3*02:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_05():
    result = parse("DRB3*02:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_06():
    result = parse("DRB3*02:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_07():
    result = parse("DRB3*02:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_08():
    result = parse("DRB3*02:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_09():
    result = parse("DRB3*02:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_10():
    result = parse("DRB3*02:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_11():
    result = parse("DRB3*02:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_12():
    result = parse("DRB3*02:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_13():
    result = parse("DRB3*02:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_14():
    result = parse("DRB3*02:02:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_15():
    result = parse("DRB3*02:02:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_16():
    result = parse("DRB3*02:02:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_17():
    result = parse("DRB3*02:02:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_18():
    result = parse("DRB3*02:02:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_19():
    result = parse("DRB3*02:02:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_20():
    result = parse("DRB3*02:02:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_21():
    result = parse("DRB3*02:02:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_22():
    result = parse("DRB3*02:02:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_23():
    result = parse("DRB3*02:02:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_24():
    result = parse("DRB3*02:02:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_02_25():
    result = parse("DRB3*02:02:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:02:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_03():
    result = parse("DRB3*02:03")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_04():
    result = parse("DRB3*02:04")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_05_01():
    result = parse("DRB3*02:05:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:05:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_05_02():
    result = parse("DRB3*02:05:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:05:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_06():
    result = parse("DRB3*02:06")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_07():
    result = parse("DRB3*02:07")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_08():
    result = parse("DRB3*02:08")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_09():
    result = parse("DRB3*02:09")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_10():
    result = parse("DRB3*02:10")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_100():
    result = parse("DRB3*02:100")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_101():
    result = parse("DRB3*02:101")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_102():
    result = parse("DRB3*02:102")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_103():
    result = parse("DRB3*02:103")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_104():
    result = parse("DRB3*02:104")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_105():
    result = parse("DRB3*02:105")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_106():
    result = parse("DRB3*02:106")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_107():
    result = parse("DRB3*02:107")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_108():
    result = parse("DRB3*02:108")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_109N():
    result = parse("DRB3*02:109N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:109N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:109N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_11():
    result = parse("DRB3*02:11")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_110():
    result = parse("DRB3*02:110")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_111():
    result = parse("DRB3*02:111")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_112():
    result = parse("DRB3*02:112")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_113():
    result = parse("DRB3*02:113")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_114():
    result = parse("DRB3*02:114")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_115():
    result = parse("DRB3*02:115")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:115") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_116():
    result = parse("DRB3*02:116")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_117():
    result = parse("DRB3*02:117")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_118():
    result = parse("DRB3*02:118")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:118") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_119():
    result = parse("DRB3*02:119")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:119") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_12():
    result = parse("DRB3*02:12")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_120():
    result = parse("DRB3*02:120")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:120") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_121N():
    result = parse("DRB3*02:121N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:121N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:121N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_122():
    result = parse("DRB3*02:122")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:122") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_123():
    result = parse("DRB3*02:123")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:123") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_124():
    result = parse("DRB3*02:124")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:124") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_125N():
    result = parse("DRB3*02:125N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:125N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:125N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_126():
    result = parse("DRB3*02:126")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:126") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_127():
    result = parse("DRB3*02:127")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:127") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_128():
    result = parse("DRB3*02:128")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:128") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_129():
    result = parse("DRB3*02:129")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:129") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_13():
    result = parse("DRB3*02:13")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_130():
    result = parse("DRB3*02:130")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:130") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_131():
    result = parse("DRB3*02:131")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:131") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_132():
    result = parse("DRB3*02:132")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:132") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_133():
    result = parse("DRB3*02:133")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:133") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_134():
    result = parse("DRB3*02:134")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:134") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_135():
    result = parse("DRB3*02:135")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:135") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_136():
    result = parse("DRB3*02:136")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:136") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_137N():
    result = parse("DRB3*02:137N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:137N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:137N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_138():
    result = parse("DRB3*02:138")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:138") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_139():
    result = parse("DRB3*02:139")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:139") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_14():
    result = parse("DRB3*02:14")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_140():
    result = parse("DRB3*02:140")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:140") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_141():
    result = parse("DRB3*02:141")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:141") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_142():
    result = parse("DRB3*02:142")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:142") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_143():
    result = parse("DRB3*02:143")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:143") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_15():
    result = parse("DRB3*02:15")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_16():
    result = parse("DRB3*02:16")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_17():
    result = parse("DRB3*02:17")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_18():
    result = parse("DRB3*02:18")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_19():
    result = parse("DRB3*02:19")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_20():
    result = parse("DRB3*02:20")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_21():
    result = parse("DRB3*02:21")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_22_01():
    result = parse("DRB3*02:22:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:22:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:22:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_22_02():
    result = parse("DRB3*02:22:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:22:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:22:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_23():
    result = parse("DRB3*02:23")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_24():
    result = parse("DRB3*02:24")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_25():
    result = parse("DRB3*02:25")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_26():
    result = parse("DRB3*02:26")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_27():
    result = parse("DRB3*02:27")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_28():
    result = parse("DRB3*02:28")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_29N():
    result = parse("DRB3*02:29N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:29N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:29N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_30():
    result = parse("DRB3*02:30")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_31_01():
    result = parse("DRB3*02:31:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:31:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:31:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_31_02():
    result = parse("DRB3*02:31:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:31:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*02:31:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_32():
    result = parse("DRB3*02:32")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_33():
    result = parse("DRB3*02:33")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_34():
    result = parse("DRB3*02:34")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_35():
    result = parse("DRB3*02:35")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_36():
    result = parse("DRB3*02:36")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_37():
    result = parse("DRB3*02:37")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_38():
    result = parse("DRB3*02:38")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_39():
    result = parse("DRB3*02:39")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_40():
    result = parse("DRB3*02:40")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_41():
    result = parse("DRB3*02:41")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_42():
    result = parse("DRB3*02:42")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_43():
    result = parse("DRB3*02:43")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_44():
    result = parse("DRB3*02:44")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_45():
    result = parse("DRB3*02:45")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_46():
    result = parse("DRB3*02:46")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_47():
    result = parse("DRB3*02:47")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_48():
    result = parse("DRB3*02:48")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_49():
    result = parse("DRB3*02:49")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_50():
    result = parse("DRB3*02:50")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_51():
    result = parse("DRB3*02:51")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_52():
    result = parse("DRB3*02:52")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_53():
    result = parse("DRB3*02:53")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_54():
    result = parse("DRB3*02:54")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_55N():
    result = parse("DRB3*02:55N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:55N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:55N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_56():
    result = parse("DRB3*02:56")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_57():
    result = parse("DRB3*02:57")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_58():
    result = parse("DRB3*02:58")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_59():
    result = parse("DRB3*02:59")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_60():
    result = parse("DRB3*02:60")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_61Q():
    result = parse("DRB3*02:61Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:61Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:61Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_62():
    result = parse("DRB3*02:62")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_63():
    result = parse("DRB3*02:63")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_64():
    result = parse("DRB3*02:64")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_65():
    result = parse("DRB3*02:65")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_66():
    result = parse("DRB3*02:66")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_67N():
    result = parse("DRB3*02:67N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:67N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:67N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_68():
    result = parse("DRB3*02:68")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_69():
    result = parse("DRB3*02:69")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_70():
    result = parse("DRB3*02:70")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_71():
    result = parse("DRB3*02:71")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_72():
    result = parse("DRB3*02:72")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_73():
    result = parse("DRB3*02:73")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_74():
    result = parse("DRB3*02:74")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_75():
    result = parse("DRB3*02:75")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_76():
    result = parse("DRB3*02:76")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_77():
    result = parse("DRB3*02:77")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_78():
    result = parse("DRB3*02:78")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_79():
    result = parse("DRB3*02:79")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_80N():
    result = parse("DRB3*02:80N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:80N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:80N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_81():
    result = parse("DRB3*02:81")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_82():
    result = parse("DRB3*02:82")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_83():
    result = parse("DRB3*02:83")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_84():
    result = parse("DRB3*02:84")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_85():
    result = parse("DRB3*02:85")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_86():
    result = parse("DRB3*02:86")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_87():
    result = parse("DRB3*02:87")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_88():
    result = parse("DRB3*02:88")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_89():
    result = parse("DRB3*02:89")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_90():
    result = parse("DRB3*02:90")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_91():
    result = parse("DRB3*02:91")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_92():
    result = parse("DRB3*02:92")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_93():
    result = parse("DRB3*02:93")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_94():
    result = parse("DRB3*02:94")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_95N():
    result = parse("DRB3*02:95N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*02:95N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:95N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_96():
    result = parse("DRB3*02:96")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_97():
    result = parse("DRB3*02:97")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_98():
    result = parse("DRB3*02:98")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_02_99():
    result = parse("DRB3*02:99")
    assert result.__class__ is Allele, f'Expected parse("DRB3*02:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*02:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_01_01_01():
    result = parse("DRB3*03:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*03:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_01_01_02():
    result = parse("DRB3*03:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*03:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_01_01_03():
    result = parse("DRB3*03:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*03:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_01_01_04():
    result = parse("DRB3*03:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*03:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_01_02():
    result = parse("DRB3*03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*03:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_01_03_01():
    result = parse("DRB3*03:01:03:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:01:03:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*03:01:03:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_01_03_02():
    result = parse("DRB3*03:01:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:01:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB3*03:01:03:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_01_04():
    result = parse("DRB3*03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*03:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_01_05():
    result = parse("DRB3*03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*03:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_01_06():
    result = parse("DRB3*03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*03:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_01_07():
    result = parse("DRB3*03:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*03:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_01_08():
    result = parse("DRB3*03:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*03:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_01_09():
    result = parse("DRB3*03:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*03:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_01_10():
    result = parse("DRB3*03:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*03:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_02():
    result = parse("DRB3*03:02")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_03():
    result = parse("DRB3*03:03")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_04_01():
    result = parse("DRB3*03:04:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:04:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*03:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_04_02():
    result = parse("DRB3*03:04:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:04:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB3*03:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_05():
    result = parse("DRB3*03:05")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_06():
    result = parse("DRB3*03:06")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_07():
    result = parse("DRB3*03:07")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_08():
    result = parse("DRB3*03:08")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_09():
    result = parse("DRB3*03:09")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_10():
    result = parse("DRB3*03:10")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_11():
    result = parse("DRB3*03:11")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_12():
    result = parse("DRB3*03:12")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_13():
    result = parse("DRB3*03:13")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_14():
    result = parse("DRB3*03:14")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_15():
    result = parse("DRB3*03:15")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_16():
    result = parse("DRB3*03:16")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_17():
    result = parse("DRB3*03:17")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_18():
    result = parse("DRB3*03:18")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_19():
    result = parse("DRB3*03:19")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_20():
    result = parse("DRB3*03:20")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_21():
    result = parse("DRB3*03:21")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_22():
    result = parse("DRB3*03:22")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_23():
    result = parse("DRB3*03:23")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_24():
    result = parse("DRB3*03:24")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_25():
    result = parse("DRB3*03:25")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_26():
    result = parse("DRB3*03:26")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_27():
    result = parse("DRB3*03:27")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_28():
    result = parse("DRB3*03:28")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_29():
    result = parse("DRB3*03:29")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_30N():
    result = parse("DRB3*03:30N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB3*03:30N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:30N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_31():
    result = parse("DRB3*03:31")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_32():
    result = parse("DRB3*03:32")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_33():
    result = parse("DRB3*03:33")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_34():
    result = parse("DRB3*03:34")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_35():
    result = parse("DRB3*03:35")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_36():
    result = parse("DRB3*03:36")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_37():
    result = parse("DRB3*03:37")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_38():
    result = parse("DRB3*03:38")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_39():
    result = parse("DRB3*03:39")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_40():
    result = parse("DRB3*03:40")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_41():
    result = parse("DRB3*03:41")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_42():
    result = parse("DRB3*03:42")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_43():
    result = parse("DRB3*03:43")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB3_03_44():
    result = parse("DRB3*03:44")
    assert result.__class__ is Allele, f'Expected parse("DRB3*03:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB3*03:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_01_01_01():
    result = parse("DRB4*01:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB4*01:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_01_01_03():
    result = parse("DRB4*01:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB4*01:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_01_02():
    result = parse("DRB4*01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_01_03():
    result = parse("DRB4*01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_01_04():
    result = parse("DRB4*01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_01_05():
    result = parse("DRB4*01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_01_06():
    result = parse("DRB4*01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_01_07():
    result = parse("DRB4*01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_01_08():
    result = parse("DRB4*01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_01_09():
    result = parse("DRB4*01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_02():
    result = parse("DRB4*01:02")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_01_01():
    result = parse("DRB4*01:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB4*01:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_01_02N():
    result = parse("DRB4*01:03:01:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:01:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB4*01:03:01:02N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_01_03():
    result = parse("DRB4*01:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB4*01:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_01_04():
    result = parse("DRB4*01:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB4*01:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_01_05():
    result = parse("DRB4*01:03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB4*01:03:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_01_06():
    result = parse("DRB4*01:03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB4*01:03:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_01_07():
    result = parse("DRB4*01:03:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB4*01:03:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_01_08():
    result = parse("DRB4*01:03:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB4*01:03:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_01_09():
    result = parse("DRB4*01:03:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB4*01:03:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_01_10():
    result = parse("DRB4*01:03:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB4*01:03:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_01_11():
    result = parse("DRB4*01:03:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB4*01:03:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_01_12():
    result = parse("DRB4*01:03:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB4*01:03:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_01_13N():
    result = parse("DRB4*01:03:01:13N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:01:13N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB4*01:03:01:13N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_02():
    result = parse("DRB4*01:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_03():
    result = parse("DRB4*01:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_04():
    result = parse("DRB4*01:03:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_05():
    result = parse("DRB4*01:03:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_06():
    result = parse("DRB4*01:03:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_07():
    result = parse("DRB4*01:03:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_08():
    result = parse("DRB4*01:03:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_09():
    result = parse("DRB4*01:03:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_10():
    result = parse("DRB4*01:03:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_11():
    result = parse("DRB4*01:03:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_12():
    result = parse("DRB4*01:03:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_13():
    result = parse("DRB4*01:03:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_14():
    result = parse("DRB4*01:03:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_15():
    result = parse("DRB4*01:03:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_16():
    result = parse("DRB4*01:03:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_17():
    result = parse("DRB4*01:03:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_03_18():
    result = parse("DRB4*01:03:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:03:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:03:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_04():
    result = parse("DRB4*01:04")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_05():
    result = parse("DRB4*01:05")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_06():
    result = parse("DRB4*01:06")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_07_01():
    result = parse("DRB4*01:07:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:07:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_07_02():
    result = parse("DRB4*01:07:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:07:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB4*01:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_08():
    result = parse("DRB4*01:08")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_09():
    result = parse("DRB4*01:09")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_10():
    result = parse("DRB4*01:10")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_100():
    result = parse("DRB4*01:100")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_101():
    result = parse("DRB4*01:101")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_102():
    result = parse("DRB4*01:102")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_103():
    result = parse("DRB4*01:103")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_104():
    result = parse("DRB4*01:104")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_105():
    result = parse("DRB4*01:105")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_106():
    result = parse("DRB4*01:106")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_107():
    result = parse("DRB4*01:107")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_108N():
    result = parse("DRB4*01:108N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:108N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:108N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_109():
    result = parse("DRB4*01:109")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_11():
    result = parse("DRB4*01:11")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_110():
    result = parse("DRB4*01:110")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_111():
    result = parse("DRB4*01:111")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_112():
    result = parse("DRB4*01:112")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_113N():
    result = parse("DRB4*01:113N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:113N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:113N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_114():
    result = parse("DRB4*01:114")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_115N():
    result = parse("DRB4*01:115N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:115N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:115N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_116():
    result = parse("DRB4*01:116")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_117():
    result = parse("DRB4*01:117")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_118():
    result = parse("DRB4*01:118")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:118") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_119():
    result = parse("DRB4*01:119")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:119") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_12():
    result = parse("DRB4*01:12")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_120():
    result = parse("DRB4*01:120")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:120") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_121N():
    result = parse("DRB4*01:121N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:121N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:121N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_122():
    result = parse("DRB4*01:122")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:122") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_123():
    result = parse("DRB4*01:123")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:123") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_124():
    result = parse("DRB4*01:124")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:124") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_125():
    result = parse("DRB4*01:125")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:125") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_13():
    result = parse("DRB4*01:13")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_14N():
    result = parse("DRB4*01:14N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:14N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:14N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_15():
    result = parse("DRB4*01:15")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_16N():
    result = parse("DRB4*01:16N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:16N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:16N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_17():
    result = parse("DRB4*01:17")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_18():
    result = parse("DRB4*01:18")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_19():
    result = parse("DRB4*01:19")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_20():
    result = parse("DRB4*01:20")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_21():
    result = parse("DRB4*01:21")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_22():
    result = parse("DRB4*01:22")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_23():
    result = parse("DRB4*01:23")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_24():
    result = parse("DRB4*01:24")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_25():
    result = parse("DRB4*01:25")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_26():
    result = parse("DRB4*01:26")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_27():
    result = parse("DRB4*01:27")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_28():
    result = parse("DRB4*01:28")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_29():
    result = parse("DRB4*01:29")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_30():
    result = parse("DRB4*01:30")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_31():
    result = parse("DRB4*01:31")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_32():
    result = parse("DRB4*01:32")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_33():
    result = parse("DRB4*01:33")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_34():
    result = parse("DRB4*01:34")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_35():
    result = parse("DRB4*01:35")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_36():
    result = parse("DRB4*01:36")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_37():
    result = parse("DRB4*01:37")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_38N():
    result = parse("DRB4*01:38N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:38N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:38N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_39():
    result = parse("DRB4*01:39")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_40():
    result = parse("DRB4*01:40")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_41():
    result = parse("DRB4*01:41")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_42():
    result = parse("DRB4*01:42")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_43():
    result = parse("DRB4*01:43")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_44():
    result = parse("DRB4*01:44")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_45():
    result = parse("DRB4*01:45")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_46():
    result = parse("DRB4*01:46")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_47():
    result = parse("DRB4*01:47")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_48():
    result = parse("DRB4*01:48")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_49():
    result = parse("DRB4*01:49")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_50():
    result = parse("DRB4*01:50")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_51():
    result = parse("DRB4*01:51")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_52():
    result = parse("DRB4*01:52")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_53():
    result = parse("DRB4*01:53")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_54N():
    result = parse("DRB4*01:54N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:54N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:54N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_55():
    result = parse("DRB4*01:55")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_56N():
    result = parse("DRB4*01:56N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:56N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:56N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_57N():
    result = parse("DRB4*01:57N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:57N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:57N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_58():
    result = parse("DRB4*01:58")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_59():
    result = parse("DRB4*01:59")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_60():
    result = parse("DRB4*01:60")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_61N():
    result = parse("DRB4*01:61N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:61N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:61N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_62():
    result = parse("DRB4*01:62")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_63():
    result = parse("DRB4*01:63")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_64():
    result = parse("DRB4*01:64")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_65N():
    result = parse("DRB4*01:65N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:65N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:65N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_66():
    result = parse("DRB4*01:66")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_67():
    result = parse("DRB4*01:67")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_68():
    result = parse("DRB4*01:68")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_69():
    result = parse("DRB4*01:69")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_70():
    result = parse("DRB4*01:70")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_71N():
    result = parse("DRB4*01:71N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:71N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:71N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_72():
    result = parse("DRB4*01:72")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_73():
    result = parse("DRB4*01:73")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_74():
    result = parse("DRB4*01:74")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_75():
    result = parse("DRB4*01:75")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_76():
    result = parse("DRB4*01:76")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_77():
    result = parse("DRB4*01:77")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_78():
    result = parse("DRB4*01:78")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_79():
    result = parse("DRB4*01:79")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_80N():
    result = parse("DRB4*01:80N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:80N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:80N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_81():
    result = parse("DRB4*01:81")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_82():
    result = parse("DRB4*01:82")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_83():
    result = parse("DRB4*01:83")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_84N():
    result = parse("DRB4*01:84N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*01:84N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:84N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_85():
    result = parse("DRB4*01:85")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_86():
    result = parse("DRB4*01:86")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_87():
    result = parse("DRB4*01:87")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_88():
    result = parse("DRB4*01:88")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_89():
    result = parse("DRB4*01:89")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_90():
    result = parse("DRB4*01:90")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_91():
    result = parse("DRB4*01:91")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_92():
    result = parse("DRB4*01:92")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_93():
    result = parse("DRB4*01:93")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_94():
    result = parse("DRB4*01:94")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_95():
    result = parse("DRB4*01:95")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_96():
    result = parse("DRB4*01:96")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_97():
    result = parse("DRB4*01:97")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_98():
    result = parse("DRB4*01:98")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_01_99():
    result = parse("DRB4*01:99")
    assert result.__class__ is Allele, f'Expected parse("DRB4*01:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*01:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB4_02_01N():
    result = parse("DRB4*02:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB4*02:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB4*02:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_01_01_01():
    result = parse("DRB5*01:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB5*01:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_01_01_02():
    result = parse("DRB5*01:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB5*01:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_01_01_03():
    result = parse("DRB5*01:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB5*01:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_01_01_04():
    result = parse("DRB5*01:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DRB5*01:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_01_02():
    result = parse("DRB5*01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB5*01:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_01_03():
    result = parse("DRB5*01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB5*01:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_01_04():
    result = parse("DRB5*01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB5*01:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_01_05():
    result = parse("DRB5*01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB5*01:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_01_06():
    result = parse("DRB5*01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB5*01:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_02():
    result = parse("DRB5*01:02")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_03():
    result = parse("DRB5*01:03")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_04():
    result = parse("DRB5*01:04")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_05():
    result = parse("DRB5*01:05")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_06():
    result = parse("DRB5*01:06")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_07():
    result = parse("DRB5*01:07")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_08_01N():
    result = parse("DRB5*01:08:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:08:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB5*01:08:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_08_02N():
    result = parse("DRB5*01:08:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:08:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB5*01:08:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_09():
    result = parse("DRB5*01:09")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_10N():
    result = parse("DRB5*01:10N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:10N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:10N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_11():
    result = parse("DRB5*01:11")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_12():
    result = parse("DRB5*01:12")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_13():
    result = parse("DRB5*01:13")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_14():
    result = parse("DRB5*01:14")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_15():
    result = parse("DRB5*01:15")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_16():
    result = parse("DRB5*01:16")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_17():
    result = parse("DRB5*01:17")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_18():
    result = parse("DRB5*01:18")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_19():
    result = parse("DRB5*01:19")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_20():
    result = parse("DRB5*01:20")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_21():
    result = parse("DRB5*01:21")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_22_01():
    result = parse("DRB5*01:22:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:22:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB5*01:22:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_22_02():
    result = parse("DRB5*01:22:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:22:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB5*01:22:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_23():
    result = parse("DRB5*01:23")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_24():
    result = parse("DRB5*01:24")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_25():
    result = parse("DRB5*01:25")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_26():
    result = parse("DRB5*01:26")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_27N():
    result = parse("DRB5*01:27N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:27N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:27N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_28():
    result = parse("DRB5*01:28")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_29():
    result = parse("DRB5*01:29")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_30():
    result = parse("DRB5*01:30")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_31():
    result = parse("DRB5*01:31")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_32():
    result = parse("DRB5*01:32")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_33():
    result = parse("DRB5*01:33")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_34():
    result = parse("DRB5*01:34")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_35():
    result = parse("DRB5*01:35")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_36():
    result = parse("DRB5*01:36")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_37():
    result = parse("DRB5*01:37")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_38():
    result = parse("DRB5*01:38")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_39():
    result = parse("DRB5*01:39")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_40():
    result = parse("DRB5*01:40")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_41():
    result = parse("DRB5*01:41")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_42():
    result = parse("DRB5*01:42")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_43():
    result = parse("DRB5*01:43")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_44():
    result = parse("DRB5*01:44")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_45():
    result = parse("DRB5*01:45")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_46():
    result = parse("DRB5*01:46")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_47():
    result = parse("DRB5*01:47")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_48N():
    result = parse("DRB5*01:48N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:48N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:48N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_49N():
    result = parse("DRB5*01:49N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:49N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:49N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_50():
    result = parse("DRB5*01:50")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_51():
    result = parse("DRB5*01:51")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_52N():
    result = parse("DRB5*01:52N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:52N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:52N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_53N():
    result = parse("DRB5*01:53N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:53N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:53N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_54():
    result = parse("DRB5*01:54")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_55():
    result = parse("DRB5*01:55")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_56():
    result = parse("DRB5*01:56")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_57():
    result = parse("DRB5*01:57")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_58N():
    result = parse("DRB5*01:58N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:58N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:58N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_59():
    result = parse("DRB5*01:59")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_60():
    result = parse("DRB5*01:60")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_61():
    result = parse("DRB5*01:61")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_62():
    result = parse("DRB5*01:62")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_63_01():
    result = parse("DRB5*01:63:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:63:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB5*01:63:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_63_02():
    result = parse("DRB5*01:63:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:63:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB5*01:63:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_64():
    result = parse("DRB5*01:64")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_65():
    result = parse("DRB5*01:65")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_66():
    result = parse("DRB5*01:66")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_67N():
    result = parse("DRB5*01:67N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:67N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:67N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_68N():
    result = parse("DRB5*01:68N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:68N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:68N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_69():
    result = parse("DRB5*01:69")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_70():
    result = parse("DRB5*01:70")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_71N():
    result = parse("DRB5*01:71N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:71N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:71N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_72():
    result = parse("DRB5*01:72")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_73():
    result = parse("DRB5*01:73")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_74():
    result = parse("DRB5*01:74")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_75():
    result = parse("DRB5*01:75")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_76():
    result = parse("DRB5*01:76")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_77():
    result = parse("DRB5*01:77")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_78():
    result = parse("DRB5*01:78")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_79Q():
    result = parse("DRB5*01:79Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:79Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:79Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_80():
    result = parse("DRB5*01:80")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_81N():
    result = parse("DRB5*01:81N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:81N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:81N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_82():
    result = parse("DRB5*01:82")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_83N():
    result = parse("DRB5*01:83N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*01:83N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:83N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_84():
    result = parse("DRB5*01:84")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_85():
    result = parse("DRB5*01:85")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_86():
    result = parse("DRB5*01:86")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_87():
    result = parse("DRB5*01:87")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_88():
    result = parse("DRB5*01:88")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_01_89():
    result = parse("DRB5*01:89")
    assert result.__class__ is Allele, f'Expected parse("DRB5*01:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*01:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_02_01():
    result = parse("DRB5*02:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*02:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB5*02:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_02_02():
    result = parse("DRB5*02:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*02:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB5*02:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_02_03():
    result = parse("DRB5*02:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*02:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DRB5*02:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_03():
    result = parse("DRB5*02:03")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_04():
    result = parse("DRB5*02:04")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_05():
    result = parse("DRB5*02:05")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_06():
    result = parse("DRB5*02:06")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_07():
    result = parse("DRB5*02:07")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_08():
    result = parse("DRB5*02:08")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_09():
    result = parse("DRB5*02:09")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_10():
    result = parse("DRB5*02:10")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_11():
    result = parse("DRB5*02:11")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_12():
    result = parse("DRB5*02:12")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_13():
    result = parse("DRB5*02:13")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_14():
    result = parse("DRB5*02:14")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_15():
    result = parse("DRB5*02:15")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_16():
    result = parse("DRB5*02:16")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_17():
    result = parse("DRB5*02:17")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_18():
    result = parse("DRB5*02:18")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_19N():
    result = parse("DRB5*02:19N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*02:19N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:19N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_20():
    result = parse("DRB5*02:20")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_21():
    result = parse("DRB5*02:21")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_22():
    result = parse("DRB5*02:22")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_23():
    result = parse("DRB5*02:23")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_24():
    result = parse("DRB5*02:24")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_25N():
    result = parse("DRB5*02:25N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*02:25N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:25N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_26N():
    result = parse("DRB5*02:26N")
    assert result.__class__ is Allele, (
        f'Expected parse("DRB5*02:26N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:26N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_27():
    result = parse("DRB5*02:27")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_28():
    result = parse("DRB5*02:28")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DRB5_02_29():
    result = parse("DRB5*02:29")
    assert result.__class__ is Allele, f'Expected parse("DRB5*02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DRB5*02:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_01():
    result = parse("DPA1*01:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_02():
    result = parse("DPA1*01:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_03():
    result = parse("DPA1*01:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_04():
    result = parse("DPA1*01:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_05():
    result = parse("DPA1*01:03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_06():
    result = parse("DPA1*01:03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_07():
    result = parse("DPA1*01:03:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_08():
    result = parse("DPA1*01:03:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_09():
    result = parse("DPA1*01:03:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_10():
    result = parse("DPA1*01:03:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_11():
    result = parse("DPA1*01:03:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_12():
    result = parse("DPA1*01:03:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_13():
    result = parse("DPA1*01:03:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_14():
    result = parse("DPA1*01:03:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_15():
    result = parse("DPA1*01:03:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_16():
    result = parse("DPA1*01:03:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_17():
    result = parse("DPA1*01:03:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_18Q():
    result = parse("DPA1*01:03:01:18Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:18Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:18Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_19():
    result = parse("DPA1*01:03:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_20():
    result = parse("DPA1*01:03:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_21():
    result = parse("DPA1*01:03:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_22():
    result = parse("DPA1*01:03:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_23():
    result = parse("DPA1*01:03:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_24():
    result = parse("DPA1*01:03:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_25():
    result = parse("DPA1*01:03:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_26():
    result = parse("DPA1*01:03:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_27():
    result = parse("DPA1*01:03:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_28():
    result = parse("DPA1*01:03:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_29():
    result = parse("DPA1*01:03:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_30():
    result = parse("DPA1*01:03:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_31():
    result = parse("DPA1*01:03:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_32():
    result = parse("DPA1*01:03:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_33():
    result = parse("DPA1*01:03:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_34():
    result = parse("DPA1*01:03:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_35():
    result = parse("DPA1*01:03:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_36():
    result = parse("DPA1*01:03:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_37():
    result = parse("DPA1*01:03:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_01_38():
    result = parse("DPA1*01:03:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*01:03:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_02():
    result = parse("DPA1*01:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_03():
    result = parse("DPA1*01:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_04():
    result = parse("DPA1*01:03:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_05():
    result = parse("DPA1*01:03:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_06():
    result = parse("DPA1*01:03:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_07():
    result = parse("DPA1*01:03:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_08():
    result = parse("DPA1*01:03:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_09():
    result = parse("DPA1*01:03:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_10():
    result = parse("DPA1*01:03:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_11():
    result = parse("DPA1*01:03:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_12():
    result = parse("DPA1*01:03:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_13():
    result = parse("DPA1*01:03:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_14():
    result = parse("DPA1*01:03:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_15():
    result = parse("DPA1*01:03:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_16():
    result = parse("DPA1*01:03:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_17():
    result = parse("DPA1*01:03:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_18():
    result = parse("DPA1*01:03:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_19():
    result = parse("DPA1*01:03:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_20():
    result = parse("DPA1*01:03:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_21():
    result = parse("DPA1*01:03:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_22():
    result = parse("DPA1*01:03:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_03_23():
    result = parse("DPA1*01:03:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:03:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:03:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_04():
    result = parse("DPA1*01:04")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_05():
    result = parse("DPA1*01:05")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_06_01():
    result = parse("DPA1*01:06:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:06:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_06_02():
    result = parse("DPA1*01:06:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:06:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*01:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_07():
    result = parse("DPA1*01:07")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_08():
    result = parse("DPA1*01:08")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_09():
    result = parse("DPA1*01:09")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_10():
    result = parse("DPA1*01:10")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_11():
    result = parse("DPA1*01:11")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_12():
    result = parse("DPA1*01:12")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_13():
    result = parse("DPA1*01:13")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_14():
    result = parse("DPA1*01:14")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_15():
    result = parse("DPA1*01:15")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_16():
    result = parse("DPA1*01:16")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_17():
    result = parse("DPA1*01:17")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_18():
    result = parse("DPA1*01:18")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_19():
    result = parse("DPA1*01:19")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_20():
    result = parse("DPA1*01:20")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_21Q():
    result = parse("DPA1*01:21Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:21Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:21Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_22():
    result = parse("DPA1*01:22")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_23():
    result = parse("DPA1*01:23")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_24():
    result = parse("DPA1*01:24")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_25():
    result = parse("DPA1*01:25")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_26():
    result = parse("DPA1*01:26")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_27():
    result = parse("DPA1*01:27")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_28():
    result = parse("DPA1*01:28")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_29N():
    result = parse("DPA1*01:29N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:29N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:29N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_30():
    result = parse("DPA1*01:30")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_31():
    result = parse("DPA1*01:31")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_32N():
    result = parse("DPA1*01:32N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:32N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:32N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_33():
    result = parse("DPA1*01:33")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_34():
    result = parse("DPA1*01:34")
    assert result.__class__ is Allele, f'Expected parse("DPA1*01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_01_35N():
    result = parse("DPA1*01:35N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*01:35N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*01:35N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_01():
    result = parse("DPA1*02:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_02():
    result = parse("DPA1*02:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_03():
    result = parse("DPA1*02:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_04():
    result = parse("DPA1*02:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_05():
    result = parse("DPA1*02:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_06():
    result = parse("DPA1*02:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_07():
    result = parse("DPA1*02:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_08():
    result = parse("DPA1*02:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_09():
    result = parse("DPA1*02:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_10():
    result = parse("DPA1*02:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_11():
    result = parse("DPA1*02:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_12():
    result = parse("DPA1*02:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_13():
    result = parse("DPA1*02:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_14():
    result = parse("DPA1*02:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_15():
    result = parse("DPA1*02:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_16():
    result = parse("DPA1*02:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_17():
    result = parse("DPA1*02:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_18():
    result = parse("DPA1*02:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_01_19():
    result = parse("DPA1*02:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_02_01():
    result = parse("DPA1*02:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_02_02():
    result = parse("DPA1*02:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_02_03():
    result = parse("DPA1*02:01:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_03():
    result = parse("DPA1*02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_04():
    result = parse("DPA1*02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_05():
    result = parse("DPA1*02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_06():
    result = parse("DPA1*02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_07():
    result = parse("DPA1*02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_08_01():
    result = parse("DPA1*02:01:08:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:08:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:08:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_08_02():
    result = parse("DPA1*02:01:08:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:08:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:08:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_08_03():
    result = parse("DPA1*02:01:08:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:08:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:01:08:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_09():
    result = parse("DPA1*02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_10():
    result = parse("DPA1*02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_11():
    result = parse("DPA1*02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_12():
    result = parse("DPA1*02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_01_13():
    result = parse("DPA1*02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_02_01():
    result = parse("DPA1*02:02:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:02:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_02_02():
    result = parse("DPA1*02:02:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:02:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_02_03():
    result = parse("DPA1*02:02:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:02:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_02_04():
    result = parse("DPA1*02:02:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:02:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_02_05():
    result = parse("DPA1*02:02:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:02:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_02_06Q():
    result = parse("DPA1*02:02:02:06Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:02:06Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:02:02:06Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_02_07():
    result = parse("DPA1*02:02:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:02:02:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_02_08():
    result = parse("DPA1*02:02:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:02:02:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_02_09():
    result = parse("DPA1*02:02:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:02:02:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_02_10():
    result = parse("DPA1*02:02:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:02:02:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_03():
    result = parse("DPA1*02:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_04():
    result = parse("DPA1*02:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_05():
    result = parse("DPA1*02:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_06():
    result = parse("DPA1*02:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_07():
    result = parse("DPA1*02:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_08():
    result = parse("DPA1*02:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_02_09():
    result = parse("DPA1*02:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_03_01():
    result = parse("DPA1*02:03:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:03:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:03:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_03_02():
    result = parse("DPA1*02:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_04():
    result = parse("DPA1*02:04")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_05():
    result = parse("DPA1*02:05")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_06():
    result = parse("DPA1*02:06")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_07_01_01():
    result = parse("DPA1*02:07:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:07:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:07:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_07_01_02():
    result = parse("DPA1*02:07:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:07:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:07:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_07_01_03():
    result = parse("DPA1*02:07:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:07:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:07:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_07_01_04():
    result = parse("DPA1*02:07:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:07:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:07:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_07_02():
    result = parse("DPA1*02:07:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:07:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPA1*02:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_08():
    result = parse("DPA1*02:08")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_09():
    result = parse("DPA1*02:09")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_10():
    result = parse("DPA1*02:10")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_11():
    result = parse("DPA1*02:11")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_12():
    result = parse("DPA1*02:12")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_13N():
    result = parse("DPA1*02:13N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:13N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:13N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_14():
    result = parse("DPA1*02:14")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_15():
    result = parse("DPA1*02:15")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_16():
    result = parse("DPA1*02:16")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_17():
    result = parse("DPA1*02:17")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_18():
    result = parse("DPA1*02:18")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_19():
    result = parse("DPA1*02:19")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_20():
    result = parse("DPA1*02:20")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_21():
    result = parse("DPA1*02:21")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_22():
    result = parse("DPA1*02:22")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_23():
    result = parse("DPA1*02:23")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_24():
    result = parse("DPA1*02:24")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_25():
    result = parse("DPA1*02:25")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_26_01_01():
    result = parse("DPA1*02:26:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:26:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:26:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_26_01_02():
    result = parse("DPA1*02:26:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:26:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*02:26:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_27():
    result = parse("DPA1*02:27")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_28():
    result = parse("DPA1*02:28")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_29():
    result = parse("DPA1*02:29")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_30():
    result = parse("DPA1*02:30")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_31():
    result = parse("DPA1*02:31")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_32N():
    result = parse("DPA1*02:32N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*02:32N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:32N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_33():
    result = parse("DPA1*02:33")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_34():
    result = parse("DPA1*02:34")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_02_35():
    result = parse("DPA1*02:35")
    assert result.__class__ is Allele, f'Expected parse("DPA1*02:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*02:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_03_01_01_01():
    result = parse("DPA1*03:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*03:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*03:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_03_01_01_02():
    result = parse("DPA1*03:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*03:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*03:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_03_01_01_03():
    result = parse("DPA1*03:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*03:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*03:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_03_01_01_04():
    result = parse("DPA1*03:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*03:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*03:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_03_01_01_05():
    result = parse("DPA1*03:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*03:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*03:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_03_01_01_06():
    result = parse("DPA1*03:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*03:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*03:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_03_01_02_01():
    result = parse("DPA1*03:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*03:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*03:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_03_01_02_02():
    result = parse("DPA1*03:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*03:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*03:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_03_02():
    result = parse("DPA1*03:02")
    assert result.__class__ is Allele, f'Expected parse("DPA1*03:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*03:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_03_03():
    result = parse("DPA1*03:03")
    assert result.__class__ is Allele, f'Expected parse("DPA1*03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*03:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_03_04():
    result = parse("DPA1*03:04")
    assert result.__class__ is Allele, f'Expected parse("DPA1*03:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*03:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_03_05Q():
    result = parse("DPA1*03:05Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*03:05Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*03:05Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_03_06():
    result = parse("DPA1*03:06")
    assert result.__class__ is Allele, f'Expected parse("DPA1*03:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPA1*03:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_04_01_01_01():
    result = parse("DPA1*04:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*04:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*04:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_04_01_01_02():
    result = parse("DPA1*04:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*04:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*04:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_04_01_01_03():
    result = parse("DPA1*04:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*04:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*04:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_04_02_01_01():
    result = parse("DPA1*04:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*04:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*04:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPA1_04_02_01_02():
    result = parse("DPA1*04:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPA1*04:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPA1*04:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_01_01():
    result = parse("DPB1*01:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*01:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_01_02():
    result = parse("DPB1*01:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*01:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_01_03():
    result = parse("DPB1*01:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*01:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_01_04():
    result = parse("DPB1*01:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*01:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_01_05():
    result = parse("DPB1*01:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*01:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_01_06():
    result = parse("DPB1*01:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*01:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_01_07():
    result = parse("DPB1*01:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*01:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_01_08():
    result = parse("DPB1*01:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*01:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_01_09():
    result = parse("DPB1*01:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*01:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_01_10():
    result = parse("DPB1*01:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*01:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_01_11():
    result = parse("DPB1*01:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*01:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_02_01():
    result = parse("DPB1*01:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*01:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_02_02():
    result = parse("DPB1*01:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*01:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_03():
    result = parse("DPB1*01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*01:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_04():
    result = parse("DPB1*01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*01:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_05():
    result = parse("DPB1*01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*01:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_01_01_06():
    result = parse("DPB1*01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*01:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_01():
    result = parse("DPB1*02:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_02():
    result = parse("DPB1*02:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_03():
    result = parse("DPB1*02:01:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_04():
    result = parse("DPB1*02:01:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_05():
    result = parse("DPB1*02:01:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_06():
    result = parse("DPB1*02:01:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_07():
    result = parse("DPB1*02:01:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_08():
    result = parse("DPB1*02:01:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_09():
    result = parse("DPB1*02:01:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_10():
    result = parse("DPB1*02:01:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_11():
    result = parse("DPB1*02:01:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_12():
    result = parse("DPB1*02:01:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_13():
    result = parse("DPB1*02:01:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_14():
    result = parse("DPB1*02:01:02:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_15():
    result = parse("DPB1*02:01:02:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_16():
    result = parse("DPB1*02:01:02:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_17():
    result = parse("DPB1*02:01:02:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_18():
    result = parse("DPB1*02:01:02:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_19():
    result = parse("DPB1*02:01:02:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_20():
    result = parse("DPB1*02:01:02:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_21():
    result = parse("DPB1*02:01:02:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_22():
    result = parse("DPB1*02:01:02:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_23():
    result = parse("DPB1*02:01:02:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_24():
    result = parse("DPB1*02:01:02:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_25():
    result = parse("DPB1*02:01:02:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_26():
    result = parse("DPB1*02:01:02:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_27():
    result = parse("DPB1*02:01:02:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_28():
    result = parse("DPB1*02:01:02:28")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_29():
    result = parse("DPB1*02:01:02:29")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_30():
    result = parse("DPB1*02:01:02:30")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_31():
    result = parse("DPB1*02:01:02:31")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_32():
    result = parse("DPB1*02:01:02:32")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_33():
    result = parse("DPB1*02:01:02:33")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_34():
    result = parse("DPB1*02:01:02:34")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_35():
    result = parse("DPB1*02:01:02:35")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_36():
    result = parse("DPB1*02:01:02:36")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_37():
    result = parse("DPB1*02:01:02:37")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_38():
    result = parse("DPB1*02:01:02:38")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_39():
    result = parse("DPB1*02:01:02:39")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_40():
    result = parse("DPB1*02:01:02:40")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_41():
    result = parse("DPB1*02:01:02:41")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_42():
    result = parse("DPB1*02:01:02:42")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:42") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_43():
    result = parse("DPB1*02:01:02:43")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:43") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_44():
    result = parse("DPB1*02:01:02:44")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:44") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_45():
    result = parse("DPB1*02:01:02:45")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:45") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_46Q():
    result = parse("DPB1*02:01:02:46Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:46Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:46Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_02_47():
    result = parse("DPB1*02:01:02:47")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:02:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:02:47") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_03():
    result = parse("DPB1*02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_04():
    result = parse("DPB1*02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_05():
    result = parse("DPB1*02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_06():
    result = parse("DPB1*02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_07():
    result = parse("DPB1*02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_08():
    result = parse("DPB1*02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_09():
    result = parse("DPB1*02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_10():
    result = parse("DPB1*02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_11():
    result = parse("DPB1*02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_12():
    result = parse("DPB1*02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_13():
    result = parse("DPB1*02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_14():
    result = parse("DPB1*02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_15():
    result = parse("DPB1*02:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_16():
    result = parse("DPB1*02:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_17():
    result = parse("DPB1*02:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_18():
    result = parse("DPB1*02:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_19():
    result = parse("DPB1*02:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_20():
    result = parse("DPB1*02:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_21():
    result = parse("DPB1*02:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_22():
    result = parse("DPB1*02:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_23():
    result = parse("DPB1*02:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_24():
    result = parse("DPB1*02:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_25():
    result = parse("DPB1*02:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_26():
    result = parse("DPB1*02:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_27():
    result = parse("DPB1*02:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_28():
    result = parse("DPB1*02:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_29():
    result = parse("DPB1*02:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_30():
    result = parse("DPB1*02:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_31():
    result = parse("DPB1*02:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_32():
    result = parse("DPB1*02:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_33():
    result = parse("DPB1*02:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_34_01():
    result = parse("DPB1*02:01:34:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:34:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:34:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_34_02():
    result = parse("DPB1*02:01:34:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:34:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:01:34:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_35():
    result = parse("DPB1*02:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_36():
    result = parse("DPB1*02:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_37():
    result = parse("DPB1*02:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_38():
    result = parse("DPB1*02:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_39():
    result = parse("DPB1*02:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_40():
    result = parse("DPB1*02:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_41():
    result = parse("DPB1*02:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_42():
    result = parse("DPB1*02:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_43():
    result = parse("DPB1*02:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_44():
    result = parse("DPB1*02:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_45():
    result = parse("DPB1*02:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_46():
    result = parse("DPB1*02:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_47():
    result = parse("DPB1*02:01:47")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_48():
    result = parse("DPB1*02:01:48")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:48") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_49():
    result = parse("DPB1*02:01:49")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:49") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_50():
    result = parse("DPB1*02:01:50")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:50") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:50") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_51():
    result = parse("DPB1*02:01:51")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:51") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:51") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_52():
    result = parse("DPB1*02:01:52")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:52") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:52") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_53():
    result = parse("DPB1*02:01:53")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:53") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:53") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_54():
    result = parse("DPB1*02:01:54")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:54") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:54") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_55():
    result = parse("DPB1*02:01:55")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:55") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:55") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_56():
    result = parse("DPB1*02:01:56")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:56") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:56") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_01_57():
    result = parse("DPB1*02:01:57")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:01:57") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:01:57") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_02_01_01():
    result = parse("DPB1*02:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_02_01_02():
    result = parse("DPB1*02:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_02_01_03():
    result = parse("DPB1*02:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_02_01_04():
    result = parse("DPB1*02:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_02_01_05():
    result = parse("DPB1*02:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_02_01_06():
    result = parse("DPB1*02:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_02_01_07():
    result = parse("DPB1*02:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*02:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_02_02():
    result = parse("DPB1*02:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_02_02_03():
    result = parse("DPB1*02:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*02:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*02:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_01_01():
    result = parse("DPB1*03:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*03:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_01_02():
    result = parse("DPB1*03:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*03:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_01_03():
    result = parse("DPB1*03:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*03:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_01_04():
    result = parse("DPB1*03:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*03:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_01_05():
    result = parse("DPB1*03:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*03:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_01_06():
    result = parse("DPB1*03:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*03:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_01_07():
    result = parse("DPB1*03:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*03:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_01_08():
    result = parse("DPB1*03:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*03:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_01_09():
    result = parse("DPB1*03:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*03:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_01_10():
    result = parse("DPB1*03:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*03:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_01_11():
    result = parse("DPB1*03:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*03:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_02():
    result = parse("DPB1*03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*03:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_03():
    result = parse("DPB1*03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*03:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_04():
    result = parse("DPB1*03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*03:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_05():
    result = parse("DPB1*03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*03:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_06():
    result = parse("DPB1*03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*03:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_07():
    result = parse("DPB1*03:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*03:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_08():
    result = parse("DPB1*03:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*03:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_09():
    result = parse("DPB1*03:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*03:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_10():
    result = parse("DPB1*03:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*03:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_11():
    result = parse("DPB1*03:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*03:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_12():
    result = parse("DPB1*03:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*03:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_03_01_13():
    result = parse("DPB1*03:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*03:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*03:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_01():
    result = parse("DPB1*04:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_02():
    result = parse("DPB1*04:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_03():
    result = parse("DPB1*04:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_04():
    result = parse("DPB1*04:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_05():
    result = parse("DPB1*04:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_06():
    result = parse("DPB1*04:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_07():
    result = parse("DPB1*04:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_08():
    result = parse("DPB1*04:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_09():
    result = parse("DPB1*04:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_10():
    result = parse("DPB1*04:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_11():
    result = parse("DPB1*04:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_12():
    result = parse("DPB1*04:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_13():
    result = parse("DPB1*04:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_14():
    result = parse("DPB1*04:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_15():
    result = parse("DPB1*04:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_16():
    result = parse("DPB1*04:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_17():
    result = parse("DPB1*04:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_18():
    result = parse("DPB1*04:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_19():
    result = parse("DPB1*04:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_20():
    result = parse("DPB1*04:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_21():
    result = parse("DPB1*04:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_22():
    result = parse("DPB1*04:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_23():
    result = parse("DPB1*04:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_24N():
    result = parse("DPB1*04:01:01:24N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:24N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:24N") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_25():
    result = parse("DPB1*04:01:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_26():
    result = parse("DPB1*04:01:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_27():
    result = parse("DPB1*04:01:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_28():
    result = parse("DPB1*04:01:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_29():
    result = parse("DPB1*04:01:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_30():
    result = parse("DPB1*04:01:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_31():
    result = parse("DPB1*04:01:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:31") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_32():
    result = parse("DPB1*04:01:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:32") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_33():
    result = parse("DPB1*04:01:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:33") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_34():
    result = parse("DPB1*04:01:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:34") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_35():
    result = parse("DPB1*04:01:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:35") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_36():
    result = parse("DPB1*04:01:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:36") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_37():
    result = parse("DPB1*04:01:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:37") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_38():
    result = parse("DPB1*04:01:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:38") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_39():
    result = parse("DPB1*04:01:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:39") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_40():
    result = parse("DPB1*04:01:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:40") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_01_41():
    result = parse("DPB1*04:01:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:01:41") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_02():
    result = parse("DPB1*04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_03():
    result = parse("DPB1*04:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_04_01():
    result = parse("DPB1*04:01:04:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:04:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:04:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_04_02():
    result = parse("DPB1*04:01:04:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:04:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:04:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_05():
    result = parse("DPB1*04:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_06():
    result = parse("DPB1*04:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_07():
    result = parse("DPB1*04:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_08():
    result = parse("DPB1*04:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_09():
    result = parse("DPB1*04:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_10():
    result = parse("DPB1*04:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_11():
    result = parse("DPB1*04:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_12():
    result = parse("DPB1*04:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_13():
    result = parse("DPB1*04:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_14():
    result = parse("DPB1*04:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_15():
    result = parse("DPB1*04:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_16():
    result = parse("DPB1*04:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_17():
    result = parse("DPB1*04:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_18():
    result = parse("DPB1*04:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_19():
    result = parse("DPB1*04:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_20():
    result = parse("DPB1*04:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_21():
    result = parse("DPB1*04:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_22():
    result = parse("DPB1*04:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_23():
    result = parse("DPB1*04:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_24():
    result = parse("DPB1*04:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_25():
    result = parse("DPB1*04:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_26():
    result = parse("DPB1*04:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_27():
    result = parse("DPB1*04:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_28():
    result = parse("DPB1*04:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_29():
    result = parse("DPB1*04:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_30():
    result = parse("DPB1*04:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_31():
    result = parse("DPB1*04:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_32():
    result = parse("DPB1*04:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_33():
    result = parse("DPB1*04:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_34():
    result = parse("DPB1*04:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_35():
    result = parse("DPB1*04:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_36():
    result = parse("DPB1*04:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_37_01():
    result = parse("DPB1*04:01:37:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:37:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:37:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_37_02():
    result = parse("DPB1*04:01:37:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:37:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:37:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_38():
    result = parse("DPB1*04:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_39_01():
    result = parse("DPB1*04:01:39:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:39:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:39:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_39_02():
    result = parse("DPB1*04:01:39:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:39:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:01:39:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_40():
    result = parse("DPB1*04:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_41():
    result = parse("DPB1*04:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_42():
    result = parse("DPB1*04:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_43():
    result = parse("DPB1*04:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_44():
    result = parse("DPB1*04:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_45():
    result = parse("DPB1*04:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_46():
    result = parse("DPB1*04:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_01_47():
    result = parse("DPB1*04:01:47")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:01:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_01_01():
    result = parse("DPB1*04:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_01_02():
    result = parse("DPB1*04:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_01_03():
    result = parse("DPB1*04:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_01_04():
    result = parse("DPB1*04:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_01_05():
    result = parse("DPB1*04:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_01_06():
    result = parse("DPB1*04:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_01_07():
    result = parse("DPB1*04:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_01_08():
    result = parse("DPB1*04:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_01_09():
    result = parse("DPB1*04:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_01_10():
    result = parse("DPB1*04:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_01_11():
    result = parse("DPB1*04:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_01_12():
    result = parse("DPB1*04:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_01_13():
    result = parse("DPB1*04:02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:02:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_01_14():
    result = parse("DPB1*04:02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:02:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_01_15():
    result = parse("DPB1*04:02:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*04:02:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_02():
    result = parse("DPB1*04:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_03():
    result = parse("DPB1*04:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_04():
    result = parse("DPB1*04:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_05():
    result = parse("DPB1*04:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_06():
    result = parse("DPB1*04:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_07():
    result = parse("DPB1*04:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_08():
    result = parse("DPB1*04:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_09():
    result = parse("DPB1*04:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_10():
    result = parse("DPB1*04:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_11():
    result = parse("DPB1*04:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_12():
    result = parse("DPB1*04:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_13():
    result = parse("DPB1*04:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_14():
    result = parse("DPB1*04:02:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_15():
    result = parse("DPB1*04:02:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_04_02_16():
    result = parse("DPB1*04:02:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*04:02:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*04:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_01_01():
    result = parse("DPB1*05:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*05:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_01_02():
    result = parse("DPB1*05:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*05:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_01_03():
    result = parse("DPB1*05:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*05:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_01_04():
    result = parse("DPB1*05:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*05:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_01_05():
    result = parse("DPB1*05:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*05:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_01_06():
    result = parse("DPB1*05:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*05:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_01_07():
    result = parse("DPB1*05:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*05:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_01_08():
    result = parse("DPB1*05:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*05:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_01_09():
    result = parse("DPB1*05:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*05:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_01_10():
    result = parse("DPB1*05:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*05:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_01_11():
    result = parse("DPB1*05:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*05:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_01_12():
    result = parse("DPB1*05:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*05:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_02():
    result = parse("DPB1*05:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*05:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_03():
    result = parse("DPB1*05:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*05:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_04():
    result = parse("DPB1*05:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*05:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_05():
    result = parse("DPB1*05:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*05:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_06():
    result = parse("DPB1*05:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*05:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_07():
    result = parse("DPB1*05:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*05:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_08():
    result = parse("DPB1*05:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*05:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_09():
    result = parse("DPB1*05:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*05:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_10():
    result = parse("DPB1*05:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*05:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_11():
    result = parse("DPB1*05:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*05:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_12():
    result = parse("DPB1*05:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*05:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_05_01_13():
    result = parse("DPB1*05:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*05:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*05:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_06_01_01_01():
    result = parse("DPB1*06:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*06:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*06:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_06_01_01_02():
    result = parse("DPB1*06:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*06:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*06:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_06_01_01_03():
    result = parse("DPB1*06:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*06:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*06:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_06_01_02():
    result = parse("DPB1*06:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*06:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*06:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_06_01_03():
    result = parse("DPB1*06:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*06:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*06:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_06_01_04():
    result = parse("DPB1*06:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*06:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*06:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_06_01_05():
    result = parse("DPB1*06:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*06:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*06:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_08_01():
    result = parse("DPB1*08:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*08:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*08:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_09_01_01():
    result = parse("DPB1*09:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*09:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*09:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_09_01_02():
    result = parse("DPB1*09:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*09:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*09:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_09_01_03():
    result = parse("DPB1*09:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*09:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*09:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_09_01_04():
    result = parse("DPB1*09:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*09:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*09:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_09_01_05():
    result = parse("DPB1*09:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*09:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*09:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1000_01():
    result = parse("DPB1*1000:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1000:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1000:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1001_01():
    result = parse("DPB1*1001:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1001:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1001:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1002_01():
    result = parse("DPB1*1002:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1002:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1002:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1003_01():
    result = parse("DPB1*1003:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1003:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1003:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1004_01():
    result = parse("DPB1*1004:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1004:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1004:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1005_01():
    result = parse("DPB1*1005:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1005:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1005:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1006_01():
    result = parse("DPB1*1006:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1006:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1006:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1007_01():
    result = parse("DPB1*1007:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1007:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1007:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1008_01():
    result = parse("DPB1*1008:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1008:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1008:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1009_01():
    result = parse("DPB1*1009:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1009:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1009:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_100_01():
    result = parse("DPB1*100:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*100:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*100:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1010_01():
    result = parse("DPB1*1010:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1010:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1010:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1011_01():
    result = parse("DPB1*1011:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1011:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1011:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1012_01():
    result = parse("DPB1*1012:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1012:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1012:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1013_01():
    result = parse("DPB1*1013:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1013:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1013:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1014_01():
    result = parse("DPB1*1014:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1014:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1014:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1015_01():
    result = parse("DPB1*1015:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1015:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1015:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1016_01():
    result = parse("DPB1*1016:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1016:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1016:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1017_01():
    result = parse("DPB1*1017:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1017:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1017:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1018_01():
    result = parse("DPB1*1018:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1018:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1018:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1019_01():
    result = parse("DPB1*1019:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1019:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1019:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_101_01():
    result = parse("DPB1*101:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*101:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*101:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1020_01():
    result = parse("DPB1*1020:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1020:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1020:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1021_01():
    result = parse("DPB1*1021:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1021:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1021:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1022_01():
    result = parse("DPB1*1022:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1022:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1022:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1023_01():
    result = parse("DPB1*1023:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1023:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1023:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1024_01():
    result = parse("DPB1*1024:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1024:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1024:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1025_01():
    result = parse("DPB1*1025:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1025:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1025:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1026_01():
    result = parse("DPB1*1026:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1026:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1026:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1027_01():
    result = parse("DPB1*1027:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1027:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1027:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1028_01():
    result = parse("DPB1*1028:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1028:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1028:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1029_01N():
    result = parse("DPB1*1029:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1029:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1029:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_102_01():
    result = parse("DPB1*102:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*102:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*102:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1030_01():
    result = parse("DPB1*1030:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1030:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1030:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1031_01():
    result = parse("DPB1*1031:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1031:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1031:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1032_01():
    result = parse("DPB1*1032:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1032:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1032:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1033_01():
    result = parse("DPB1*1033:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1033:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1033:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1034_01():
    result = parse("DPB1*1034:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1034:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1034:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1035_01():
    result = parse("DPB1*1035:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1035:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1035:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1036_01():
    result = parse("DPB1*1036:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1036:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1036:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1037_01():
    result = parse("DPB1*1037:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1037:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1037:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1038_01Q():
    result = parse("DPB1*1038:01Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1038:01Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1038:01Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1039_01():
    result = parse("DPB1*1039:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1039:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1039:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_103_01():
    result = parse("DPB1*103:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*103:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*103:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1040_01():
    result = parse("DPB1*1040:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1040:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1040:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1041_01N():
    result = parse("DPB1*1041:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1041:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1041:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1042_01():
    result = parse("DPB1*1042:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1042:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1042:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1043_01():
    result = parse("DPB1*1043:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1043:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1043:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1044_01N():
    result = parse("DPB1*1044:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1044:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1044:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1045_01N():
    result = parse("DPB1*1045:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1045:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1045:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1046_01():
    result = parse("DPB1*1046:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1046:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1046:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1047_01():
    result = parse("DPB1*1047:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1047:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1047:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1048_01():
    result = parse("DPB1*1048:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1048:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1048:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1049_01():
    result = parse("DPB1*1049:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1049:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1049:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_104_01_01_01():
    result = parse("DPB1*104:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*104:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*104:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_104_01_01_02():
    result = parse("DPB1*104:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*104:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*104:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_104_01_01_03():
    result = parse("DPB1*104:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*104:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*104:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_104_01_01_04():
    result = parse("DPB1*104:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*104:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*104:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_104_01_01_05():
    result = parse("DPB1*104:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*104:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*104:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_104_01_01_06():
    result = parse("DPB1*104:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*104:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*104:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_104_01_02():
    result = parse("DPB1*104:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*104:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*104:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_104_01_03():
    result = parse("DPB1*104:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*104:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*104:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_104_01_04():
    result = parse("DPB1*104:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*104:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*104:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1050_01():
    result = parse("DPB1*1050:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1050:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1050:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1051_01():
    result = parse("DPB1*1051:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1051:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1051:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1052_01():
    result = parse("DPB1*1052:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1052:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1052:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1053_01():
    result = parse("DPB1*1053:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1053:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1053:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1054_01():
    result = parse("DPB1*1054:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1054:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1054:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1055_01():
    result = parse("DPB1*1055:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1055:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1055:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1056_01():
    result = parse("DPB1*1056:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1056:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1056:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1057_01():
    result = parse("DPB1*1057:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1057:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1057:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1058_01():
    result = parse("DPB1*1058:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1058:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1058:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1059_01():
    result = parse("DPB1*1059:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1059:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1059:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_105_01_01_01():
    result = parse("DPB1*105:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*105:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*105:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_105_01_01_02():
    result = parse("DPB1*105:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*105:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*105:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_105_01_01_03():
    result = parse("DPB1*105:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*105:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*105:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_105_01_01_04():
    result = parse("DPB1*105:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*105:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*105:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_105_01_01_05():
    result = parse("DPB1*105:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*105:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*105:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_105_01_01_06():
    result = parse("DPB1*105:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*105:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*105:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_105_01_01_07():
    result = parse("DPB1*105:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*105:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*105:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_105_01_01_08():
    result = parse("DPB1*105:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*105:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*105:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_105_01_01_09():
    result = parse("DPB1*105:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*105:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*105:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_105_01_01_10():
    result = parse("DPB1*105:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*105:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*105:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1060_01():
    result = parse("DPB1*1060:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1060:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1060:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1061_01():
    result = parse("DPB1*1061:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1061:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1061:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1062_01():
    result = parse("DPB1*1062:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1062:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1062:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1063_01():
    result = parse("DPB1*1063:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1063:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1063:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1064_01():
    result = parse("DPB1*1064:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1064:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1064:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1065_01():
    result = parse("DPB1*1065:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1065:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1065:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1066_01():
    result = parse("DPB1*1066:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1066:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1066:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1067_01():
    result = parse("DPB1*1067:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1067:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1067:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1068_01():
    result = parse("DPB1*1068:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1068:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1068:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1069_01():
    result = parse("DPB1*1069:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1069:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1069:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_106_01():
    result = parse("DPB1*106:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*106:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*106:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1070_01N():
    result = parse("DPB1*1070:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1070:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1070:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1071_01():
    result = parse("DPB1*1071:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1071:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1071:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1072_01():
    result = parse("DPB1*1072:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1072:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1072:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1073_01():
    result = parse("DPB1*1073:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1073:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1073:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1074_01():
    result = parse("DPB1*1074:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1074:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1074:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1075_01():
    result = parse("DPB1*1075:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1075:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1075:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1076_01():
    result = parse("DPB1*1076:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1076:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1076:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1077_01():
    result = parse("DPB1*1077:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1077:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1077:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1078_01():
    result = parse("DPB1*1078:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1078:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1078:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1079_01N():
    result = parse("DPB1*1079:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1079:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1079:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_107_01():
    result = parse("DPB1*107:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*107:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*107:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1080_01():
    result = parse("DPB1*1080:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1080:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1080:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1081_01():
    result = parse("DPB1*1081:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1081:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1081:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1082_01():
    result = parse("DPB1*1082:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1082:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1082:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1083_01():
    result = parse("DPB1*1083:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1083:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1083:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1084_01N():
    result = parse("DPB1*1084:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1084:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1084:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1085_01():
    result = parse("DPB1*1085:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1085:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1085:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1086_01():
    result = parse("DPB1*1086:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1086:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1086:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1087_01():
    result = parse("DPB1*1087:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1087:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1087:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1088_01():
    result = parse("DPB1*1088:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1088:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1088:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1089_01():
    result = parse("DPB1*1089:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1089:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1089:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_108_01():
    result = parse("DPB1*108:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*108:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*108:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1090_01():
    result = parse("DPB1*1090:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1090:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1090:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1091_01():
    result = parse("DPB1*1091:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1091:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1091:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1092_01Q():
    result = parse("DPB1*1092:01Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1092:01Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1092:01Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1093_01():
    result = parse("DPB1*1093:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1093:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1093:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1094_01():
    result = parse("DPB1*1094:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1094:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1094:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1095_01():
    result = parse("DPB1*1095:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1095:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1095:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1096_01():
    result = parse("DPB1*1096:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1096:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1096:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1097_01():
    result = parse("DPB1*1097:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1097:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1097:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1098_01N():
    result = parse("DPB1*1098:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1098:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1098:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1099_01():
    result = parse("DPB1*1099:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1099:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1099:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_109_01():
    result = parse("DPB1*109:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*109:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*109:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_10_01_01_01():
    result = parse("DPB1*10:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*10:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*10:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_10_01_01_02():
    result = parse("DPB1*10:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*10:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*10:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_10_01_02():
    result = parse("DPB1*10:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*10:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*10:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_10_01_03():
    result = parse("DPB1*10:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*10:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*10:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_10_01_04():
    result = parse("DPB1*10:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*10:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*10:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_10_01_05():
    result = parse("DPB1*10:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*10:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*10:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1100_01():
    result = parse("DPB1*1100:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1100:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1100:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1101_01():
    result = parse("DPB1*1101:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1101:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1101:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1102_01():
    result = parse("DPB1*1102:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1102:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1102:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1103_01():
    result = parse("DPB1*1103:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1103:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1103:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1104_01():
    result = parse("DPB1*1104:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1104:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1104:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1105_01():
    result = parse("DPB1*1105:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1105:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1105:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1106_01():
    result = parse("DPB1*1106:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1106:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1106:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1107_01():
    result = parse("DPB1*1107:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1107:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1107:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1108_01():
    result = parse("DPB1*1108:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1108:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1108:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1109_01():
    result = parse("DPB1*1109:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1109:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1109:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_110_01():
    result = parse("DPB1*110:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*110:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*110:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1110_01():
    result = parse("DPB1*1110:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1110:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1110:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1111_01():
    result = parse("DPB1*1111:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1111:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1111:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1112_01N():
    result = parse("DPB1*1112:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1112:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1112:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1113_01():
    result = parse("DPB1*1113:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1113:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1113:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1114_01():
    result = parse("DPB1*1114:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1114:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1114:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1115_01():
    result = parse("DPB1*1115:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1115:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1115:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1116_01():
    result = parse("DPB1*1116:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1116:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1116:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1117_01():
    result = parse("DPB1*1117:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1117:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1117:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1118_01():
    result = parse("DPB1*1118:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1118:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1118:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1119_01():
    result = parse("DPB1*1119:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1119:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1119:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_111_01():
    result = parse("DPB1*111:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*111:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*111:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_1120_01():
    result = parse("DPB1*1120:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*1120:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*1120:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_112_01():
    result = parse("DPB1*112:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*112:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*112:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_113_01():
    result = parse("DPB1*113:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*113:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*113:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_114_01():
    result = parse("DPB1*114:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*114:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*114:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_115_01():
    result = parse("DPB1*115:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*115:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*115:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_116_01():
    result = parse("DPB1*116:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*116:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*116:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_117_01():
    result = parse("DPB1*117:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*117:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*117:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_118_01():
    result = parse("DPB1*118:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*118:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*118:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_119_01():
    result = parse("DPB1*119:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*119:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*119:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_11_01_01_01():
    result = parse("DPB1*11:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*11:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*11:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_11_01_01_02():
    result = parse("DPB1*11:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*11:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*11:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_11_01_02():
    result = parse("DPB1*11:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*11:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*11:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_11_01_03():
    result = parse("DPB1*11:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*11:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*11:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_11_01_04():
    result = parse("DPB1*11:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*11:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*11:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_11_01_05():
    result = parse("DPB1*11:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*11:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*11:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_120_01N():
    result = parse("DPB1*120:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*120:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*120:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_121_01():
    result = parse("DPB1*121:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*121:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*121:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_122_01():
    result = parse("DPB1*122:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*122:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*122:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_123_01():
    result = parse("DPB1*123:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*123:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*123:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_124_01_01_01():
    result = parse("DPB1*124:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*124:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*124:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_124_01_01_02():
    result = parse("DPB1*124:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*124:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*124:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_124_01_02_01():
    result = parse("DPB1*124:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*124:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*124:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_124_01_02_02():
    result = parse("DPB1*124:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*124:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*124:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_125_01():
    result = parse("DPB1*125:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*125:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*125:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_126_01_01_01():
    result = parse("DPB1*126:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*126:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*126:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_126_01_01_02():
    result = parse("DPB1*126:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*126:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*126:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_127_01():
    result = parse("DPB1*127:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*127:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*127:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_128_01():
    result = parse("DPB1*128:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*128:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*128:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_129_01():
    result = parse("DPB1*129:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*129:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*129:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_130_01():
    result = parse("DPB1*130:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*130:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*130:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_131_01_01_01():
    result = parse("DPB1*131:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*131:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*131:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_131_01_01_02():
    result = parse("DPB1*131:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*131:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*131:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_131_01_02():
    result = parse("DPB1*131:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*131:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*131:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_131_01_03():
    result = parse("DPB1*131:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*131:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*131:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_132_01():
    result = parse("DPB1*132:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*132:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*132:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_133_01():
    result = parse("DPB1*133:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*133:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*133:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_134_01():
    result = parse("DPB1*134:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*134:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*134:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_135_01():
    result = parse("DPB1*135:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*135:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*135:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_136_01():
    result = parse("DPB1*136:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*136:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*136:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_137_01():
    result = parse("DPB1*137:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*137:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*137:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_138_01():
    result = parse("DPB1*138:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*138:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*138:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_139_01():
    result = parse("DPB1*139:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*139:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*139:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_13_01_01_01():
    result = parse("DPB1*13:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*13:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*13:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_13_01_01_02():
    result = parse("DPB1*13:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*13:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*13:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_13_01_01_03():
    result = parse("DPB1*13:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*13:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*13:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_13_01_01_04():
    result = parse("DPB1*13:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*13:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*13:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_13_01_01_05():
    result = parse("DPB1*13:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*13:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*13:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_13_01_01_06():
    result = parse("DPB1*13:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*13:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*13:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_13_01_01_07():
    result = parse("DPB1*13:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*13:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*13:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_13_01_01_08():
    result = parse("DPB1*13:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*13:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*13:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_13_01_01_09():
    result = parse("DPB1*13:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*13:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*13:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_13_01_01_10():
    result = parse("DPB1*13:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*13:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*13:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_13_01_01_11():
    result = parse("DPB1*13:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*13:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*13:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_13_01_02():
    result = parse("DPB1*13:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*13:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*13:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_13_01_03():
    result = parse("DPB1*13:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*13:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*13:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_13_01_04():
    result = parse("DPB1*13:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*13:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*13:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_140_01():
    result = parse("DPB1*140:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*140:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*140:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_141_01():
    result = parse("DPB1*141:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*141:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*141:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_142_01():
    result = parse("DPB1*142:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*142:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*142:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_143_01():
    result = parse("DPB1*143:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*143:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*143:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_144_01():
    result = parse("DPB1*144:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*144:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*144:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_145_01():
    result = parse("DPB1*145:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*145:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*145:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_146_01():
    result = parse("DPB1*146:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*146:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*146:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_147_01():
    result = parse("DPB1*147:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*147:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*147:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_148_01():
    result = parse("DPB1*148:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*148:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*148:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_149_01():
    result = parse("DPB1*149:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*149:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*149:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_14_01_01_01():
    result = parse("DPB1*14:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*14:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*14:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_14_01_01_02():
    result = parse("DPB1*14:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*14:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*14:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_14_01_01_03():
    result = parse("DPB1*14:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*14:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*14:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_14_01_01_04():
    result = parse("DPB1*14:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*14:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*14:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_14_01_02():
    result = parse("DPB1*14:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*14:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*14:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_14_01_03():
    result = parse("DPB1*14:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*14:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*14:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_14_01_04():
    result = parse("DPB1*14:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*14:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*14:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_14_01_05():
    result = parse("DPB1*14:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*14:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*14:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_14_01_06():
    result = parse("DPB1*14:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*14:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*14:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_14_01_07():
    result = parse("DPB1*14:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*14:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*14:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_14_01_08():
    result = parse("DPB1*14:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*14:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*14:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_14_01_09():
    result = parse("DPB1*14:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*14:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*14:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_14_01_10():
    result = parse("DPB1*14:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*14:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*14:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_14_01_11():
    result = parse("DPB1*14:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*14:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*14:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_14_01_12():
    result = parse("DPB1*14:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*14:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*14:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_150_01():
    result = parse("DPB1*150:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*150:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*150:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_151_01():
    result = parse("DPB1*151:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*151:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*151:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_152_01():
    result = parse("DPB1*152:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*152:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*152:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_153_01():
    result = parse("DPB1*153:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*153:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*153:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_154_01N():
    result = parse("DPB1*154:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*154:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*154:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_155_01_01():
    result = parse("DPB1*155:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*155:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*155:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_155_01_02():
    result = parse("DPB1*155:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*155:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*155:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_156_01():
    result = parse("DPB1*156:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*156:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*156:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_157_01():
    result = parse("DPB1*157:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*157:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*157:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_158_01():
    result = parse("DPB1*158:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*158:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*158:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_159_01N():
    result = parse("DPB1*159:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*159:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*159:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_15_01_01_01():
    result = parse("DPB1*15:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*15:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*15:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_15_01_01_02():
    result = parse("DPB1*15:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*15:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*15:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_15_01_01_03():
    result = parse("DPB1*15:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*15:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*15:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_15_01_01_04():
    result = parse("DPB1*15:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*15:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*15:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_15_01_02():
    result = parse("DPB1*15:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*15:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*15:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_15_01_03():
    result = parse("DPB1*15:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*15:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*15:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_160_01():
    result = parse("DPB1*160:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*160:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*160:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_161_01N():
    result = parse("DPB1*161:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*161:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*161:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_162_01_01():
    result = parse("DPB1*162:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*162:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*162:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_162_01_02():
    result = parse("DPB1*162:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*162:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*162:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_163_01():
    result = parse("DPB1*163:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*163:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*163:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_164_01():
    result = parse("DPB1*164:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*164:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*164:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_165_01():
    result = parse("DPB1*165:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*165:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*165:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_166_01():
    result = parse("DPB1*166:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*166:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*166:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_167_01():
    result = parse("DPB1*167:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*167:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*167:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_168_01():
    result = parse("DPB1*168:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*168:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*168:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_169_01():
    result = parse("DPB1*169:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*169:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*169:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_16_01_01_01():
    result = parse("DPB1*16:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*16:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*16:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_16_01_01_02():
    result = parse("DPB1*16:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*16:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*16:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_16_01_02():
    result = parse("DPB1*16:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*16:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*16:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_16_01_03():
    result = parse("DPB1*16:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*16:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*16:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_170_01():
    result = parse("DPB1*170:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*170:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*170:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_171_01():
    result = parse("DPB1*171:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*171:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*171:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_172_01():
    result = parse("DPB1*172:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*172:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*172:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_173_01():
    result = parse("DPB1*173:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*173:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*173:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_174_01():
    result = parse("DPB1*174:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*174:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*174:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_175_01():
    result = parse("DPB1*175:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*175:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*175:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_176_01():
    result = parse("DPB1*176:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*176:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*176:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_177_01():
    result = parse("DPB1*177:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*177:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*177:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_178_01():
    result = parse("DPB1*178:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*178:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*178:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_179_01():
    result = parse("DPB1*179:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*179:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*179:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_17_01_01_01():
    result = parse("DPB1*17:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*17:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*17:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_17_01_01_02():
    result = parse("DPB1*17:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*17:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*17:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_17_01_02():
    result = parse("DPB1*17:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*17:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*17:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_17_01_03():
    result = parse("DPB1*17:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*17:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*17:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_180_01():
    result = parse("DPB1*180:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*180:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*180:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_181_01():
    result = parse("DPB1*181:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*181:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*181:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_182_01():
    result = parse("DPB1*182:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*182:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*182:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_183_01():
    result = parse("DPB1*183:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*183:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*183:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_184_01():
    result = parse("DPB1*184:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*184:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*184:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_185_01():
    result = parse("DPB1*185:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*185:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*185:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_186_01():
    result = parse("DPB1*186:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*186:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*186:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_187_01():
    result = parse("DPB1*187:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*187:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*187:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_188_01():
    result = parse("DPB1*188:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*188:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*188:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_189_01():
    result = parse("DPB1*189:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*189:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*189:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_18_01_01_01():
    result = parse("DPB1*18:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*18:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*18:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_18_01_01_02():
    result = parse("DPB1*18:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*18:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*18:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_18_01_01_03():
    result = parse("DPB1*18:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*18:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*18:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_18_01_01_04():
    result = parse("DPB1*18:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*18:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*18:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_18_01_02():
    result = parse("DPB1*18:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*18:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*18:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_18_01_03():
    result = parse("DPB1*18:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*18:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*18:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_190_01():
    result = parse("DPB1*190:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*190:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*190:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_191_01():
    result = parse("DPB1*191:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*191:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*191:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_192_01():
    result = parse("DPB1*192:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*192:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*192:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_193_01():
    result = parse("DPB1*193:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*193:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*193:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_194_01():
    result = parse("DPB1*194:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*194:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*194:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_195_01():
    result = parse("DPB1*195:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*195:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*195:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_196_01():
    result = parse("DPB1*196:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*196:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*196:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_197_01():
    result = parse("DPB1*197:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*197:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*197:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_198_01():
    result = parse("DPB1*198:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*198:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*198:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_199_01():
    result = parse("DPB1*199:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*199:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*199:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_19_01_01_01():
    result = parse("DPB1*19:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*19:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*19:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_19_01_01_02():
    result = parse("DPB1*19:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*19:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*19:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_19_01_01_03():
    result = parse("DPB1*19:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*19:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*19:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_200_01():
    result = parse("DPB1*200:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*200:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*200:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_201_01():
    result = parse("DPB1*201:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*201:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*201:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_202_01():
    result = parse("DPB1*202:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*202:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*202:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_203_01_01():
    result = parse("DPB1*203:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*203:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*203:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_203_01_02():
    result = parse("DPB1*203:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*203:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*203:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_204_01():
    result = parse("DPB1*204:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*204:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*204:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_205_01():
    result = parse("DPB1*205:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*205:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*205:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_206_01():
    result = parse("DPB1*206:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*206:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*206:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_207_01():
    result = parse("DPB1*207:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*207:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*207:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_208_01():
    result = parse("DPB1*208:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*208:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*208:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_209_01():
    result = parse("DPB1*209:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*209:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*209:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_20_01_01_01():
    result = parse("DPB1*20:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*20:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*20:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_20_01_01_02():
    result = parse("DPB1*20:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*20:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*20:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_20_01_02():
    result = parse("DPB1*20:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*20:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*20:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_20_01_03():
    result = parse("DPB1*20:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*20:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*20:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_20_01_04():
    result = parse("DPB1*20:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*20:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*20:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_210_01():
    result = parse("DPB1*210:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*210:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*210:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_211_01():
    result = parse("DPB1*211:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*211:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*211:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_212_01():
    result = parse("DPB1*212:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*212:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*212:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_213_01_01():
    result = parse("DPB1*213:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*213:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*213:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_213_01_02():
    result = parse("DPB1*213:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*213:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*213:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_214_01():
    result = parse("DPB1*214:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*214:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*214:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_215_01():
    result = parse("DPB1*215:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*215:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*215:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_216_01N():
    result = parse("DPB1*216:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*216:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*216:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_217_01():
    result = parse("DPB1*217:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*217:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*217:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_218_01N():
    result = parse("DPB1*218:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*218:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*218:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_219_01():
    result = parse("DPB1*219:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*219:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*219:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_21_01():
    result = parse("DPB1*21:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*21:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*21:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_220_01():
    result = parse("DPB1*220:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*220:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*220:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_221_01():
    result = parse("DPB1*221:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*221:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*221:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_222_01():
    result = parse("DPB1*222:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*222:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*222:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_223_01():
    result = parse("DPB1*223:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*223:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*223:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_224_01():
    result = parse("DPB1*224:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*224:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*224:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_225_01():
    result = parse("DPB1*225:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*225:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*225:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_226_01():
    result = parse("DPB1*226:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*226:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*226:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_227_01_01():
    result = parse("DPB1*227:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*227:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*227:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_227_01_02():
    result = parse("DPB1*227:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*227:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*227:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_227_01_03():
    result = parse("DPB1*227:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*227:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*227:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_228_01():
    result = parse("DPB1*228:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*228:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*228:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_229_01():
    result = parse("DPB1*229:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*229:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*229:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_22_01_01_01():
    result = parse("DPB1*22:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*22:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*22:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_22_01_01_02():
    result = parse("DPB1*22:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*22:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*22:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_230_01():
    result = parse("DPB1*230:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*230:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*230:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_231_01():
    result = parse("DPB1*231:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*231:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*231:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_232_01():
    result = parse("DPB1*232:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*232:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*232:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_233_01():
    result = parse("DPB1*233:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*233:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*233:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_234_01():
    result = parse("DPB1*234:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*234:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*234:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_235_01():
    result = parse("DPB1*235:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*235:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*235:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_236_01_01():
    result = parse("DPB1*236:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*236:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*236:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_236_01_02():
    result = parse("DPB1*236:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*236:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*236:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_237_01():
    result = parse("DPB1*237:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*237:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*237:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_238_01():
    result = parse("DPB1*238:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*238:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*238:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_239_01():
    result = parse("DPB1*239:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*239:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*239:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_23_01_01_01():
    result = parse("DPB1*23:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*23:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*23:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_23_01_01_02():
    result = parse("DPB1*23:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*23:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*23:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_23_01_02():
    result = parse("DPB1*23:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*23:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*23:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_240_01():
    result = parse("DPB1*240:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*240:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*240:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_241_01():
    result = parse("DPB1*241:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*241:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*241:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_242_01():
    result = parse("DPB1*242:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*242:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*242:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_243_01():
    result = parse("DPB1*243:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*243:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*243:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_244_01():
    result = parse("DPB1*244:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*244:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*244:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_245_01():
    result = parse("DPB1*245:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*245:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*245:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_246_01():
    result = parse("DPB1*246:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*246:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*246:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_247_01():
    result = parse("DPB1*247:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*247:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*247:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_248_01():
    result = parse("DPB1*248:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*248:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*248:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_249_01():
    result = parse("DPB1*249:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*249:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*249:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_24_01():
    result = parse("DPB1*24:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*24:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*24:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_250_01():
    result = parse("DPB1*250:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*250:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*250:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_251_01():
    result = parse("DPB1*251:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*251:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*251:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_252_01():
    result = parse("DPB1*252:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*252:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*252:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_253_01():
    result = parse("DPB1*253:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*253:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*253:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_254_01():
    result = parse("DPB1*254:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*254:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*254:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_255_01():
    result = parse("DPB1*255:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*255:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*255:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_256_01():
    result = parse("DPB1*256:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*256:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*256:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_257_01():
    result = parse("DPB1*257:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*257:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*257:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_258_01():
    result = parse("DPB1*258:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*258:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*258:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_259_01():
    result = parse("DPB1*259:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*259:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*259:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_25_01():
    result = parse("DPB1*25:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*25:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*25:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_260_01():
    result = parse("DPB1*260:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*260:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*260:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_261_01():
    result = parse("DPB1*261:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*261:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*261:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_262_01():
    result = parse("DPB1*262:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*262:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*262:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_263_01():
    result = parse("DPB1*263:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*263:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*263:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_264_01():
    result = parse("DPB1*264:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*264:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*264:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_265_01():
    result = parse("DPB1*265:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*265:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*265:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_266_01():
    result = parse("DPB1*266:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*266:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*266:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_267_01():
    result = parse("DPB1*267:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*267:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*267:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_268_01():
    result = parse("DPB1*268:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*268:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*268:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_269_01():
    result = parse("DPB1*269:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*269:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*269:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_26_01_01():
    result = parse("DPB1*26:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*26:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*26:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_26_01_02():
    result = parse("DPB1*26:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*26:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*26:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_26_01_03():
    result = parse("DPB1*26:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*26:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*26:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_270_01():
    result = parse("DPB1*270:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*270:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*270:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_271_01():
    result = parse("DPB1*271:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*271:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*271:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_272_01():
    result = parse("DPB1*272:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*272:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*272:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_273_01():
    result = parse("DPB1*273:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*273:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*273:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_274_01():
    result = parse("DPB1*274:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*274:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*274:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_275_01():
    result = parse("DPB1*275:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*275:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*275:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_276_01():
    result = parse("DPB1*276:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*276:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*276:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_277_01():
    result = parse("DPB1*277:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*277:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*277:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_278_01():
    result = parse("DPB1*278:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*278:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*278:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_279_01_01():
    result = parse("DPB1*279:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*279:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*279:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_279_01_02():
    result = parse("DPB1*279:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*279:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*279:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_27_01():
    result = parse("DPB1*27:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*27:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*27:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_280_01():
    result = parse("DPB1*280:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*280:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*280:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_281_01():
    result = parse("DPB1*281:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*281:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*281:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_282_01():
    result = parse("DPB1*282:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*282:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*282:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_283_01():
    result = parse("DPB1*283:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*283:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*283:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_284_01():
    result = parse("DPB1*284:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*284:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*284:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_285_01():
    result = parse("DPB1*285:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*285:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*285:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_286_01():
    result = parse("DPB1*286:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*286:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*286:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_287_01():
    result = parse("DPB1*287:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*287:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*287:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_288_01():
    result = parse("DPB1*288:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*288:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*288:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_289_01():
    result = parse("DPB1*289:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*289:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*289:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_28_01():
    result = parse("DPB1*28:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*28:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*28:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_290_01():
    result = parse("DPB1*290:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*290:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*290:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_291_01():
    result = parse("DPB1*291:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*291:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*291:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_292_01():
    result = parse("DPB1*292:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*292:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*292:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_293_01():
    result = parse("DPB1*293:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*293:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*293:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_294_01():
    result = parse("DPB1*294:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*294:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*294:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_295_01():
    result = parse("DPB1*295:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*295:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*295:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_296_01():
    result = parse("DPB1*296:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*296:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*296:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_297_01():
    result = parse("DPB1*297:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*297:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*297:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_298_01():
    result = parse("DPB1*298:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*298:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*298:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_299_01():
    result = parse("DPB1*299:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*299:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*299:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_29_01():
    result = parse("DPB1*29:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*29:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*29:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_300_01():
    result = parse("DPB1*300:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*300:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*300:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_301_01():
    result = parse("DPB1*301:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*301:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*301:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_302_01():
    result = parse("DPB1*302:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*302:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*302:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_303_01():
    result = parse("DPB1*303:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*303:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*303:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_304_01():
    result = parse("DPB1*304:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*304:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*304:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_305_01():
    result = parse("DPB1*305:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*305:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*305:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_306_01():
    result = parse("DPB1*306:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*306:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*306:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_307_01():
    result = parse("DPB1*307:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*307:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*307:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_308_01():
    result = parse("DPB1*308:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*308:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*308:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_309_01():
    result = parse("DPB1*309:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*309:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*309:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_30_01_01_01():
    result = parse("DPB1*30:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*30:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*30:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_30_01_01_02():
    result = parse("DPB1*30:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*30:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*30:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_310_01():
    result = parse("DPB1*310:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*310:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*310:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_311_01():
    result = parse("DPB1*311:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*311:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*311:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_312_01():
    result = parse("DPB1*312:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*312:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*312:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_313_01():
    result = parse("DPB1*313:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*313:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*313:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_314_01():
    result = parse("DPB1*314:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*314:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*314:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_315_01():
    result = parse("DPB1*315:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*315:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*315:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_316_01():
    result = parse("DPB1*316:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*316:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*316:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_317_01():
    result = parse("DPB1*317:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*317:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*317:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_318_01():
    result = parse("DPB1*318:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*318:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*318:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_319_01():
    result = parse("DPB1*319:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*319:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*319:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_31_01_01_01():
    result = parse("DPB1*31:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*31:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*31:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_31_01_01_02():
    result = parse("DPB1*31:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*31:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*31:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_320_01():
    result = parse("DPB1*320:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*320:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*320:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_321_01():
    result = parse("DPB1*321:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*321:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*321:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_322_01():
    result = parse("DPB1*322:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*322:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*322:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_323_01():
    result = parse("DPB1*323:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*323:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*323:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_324_01():
    result = parse("DPB1*324:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*324:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*324:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_325_01():
    result = parse("DPB1*325:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*325:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*325:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_326_01():
    result = parse("DPB1*326:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*326:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*326:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_327_01():
    result = parse("DPB1*327:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*327:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*327:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_328_01N():
    result = parse("DPB1*328:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*328:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*328:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_329_01():
    result = parse("DPB1*329:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*329:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*329:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_32_01():
    result = parse("DPB1*32:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*32:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*32:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_330_01():
    result = parse("DPB1*330:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*330:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*330:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_331_01():
    result = parse("DPB1*331:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*331:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*331:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_332_01():
    result = parse("DPB1*332:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*332:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*332:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_333_01():
    result = parse("DPB1*333:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*333:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*333:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_334_01_01():
    result = parse("DPB1*334:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*334:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*334:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_334_01_02():
    result = parse("DPB1*334:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*334:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*334:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_335_01():
    result = parse("DPB1*335:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*335:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*335:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_336_01():
    result = parse("DPB1*336:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*336:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*336:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_337_01():
    result = parse("DPB1*337:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*337:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*337:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_338_01():
    result = parse("DPB1*338:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*338:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*338:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_339_01():
    result = parse("DPB1*339:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*339:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*339:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_33_01_01_01():
    result = parse("DPB1*33:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*33:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*33:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_33_01_01_02():
    result = parse("DPB1*33:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*33:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*33:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_33_01_01_03():
    result = parse("DPB1*33:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*33:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*33:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_33_01_01_04():
    result = parse("DPB1*33:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*33:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*33:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_33_01_01_05():
    result = parse("DPB1*33:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*33:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*33:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_340_01():
    result = parse("DPB1*340:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*340:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*340:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_341_01():
    result = parse("DPB1*341:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*341:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*341:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_342_01():
    result = parse("DPB1*342:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*342:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*342:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_343_01():
    result = parse("DPB1*343:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*343:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*343:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_344_01():
    result = parse("DPB1*344:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*344:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*344:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_345_01():
    result = parse("DPB1*345:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*345:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*345:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_346_01():
    result = parse("DPB1*346:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*346:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*346:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_347_01():
    result = parse("DPB1*347:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*347:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*347:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_348_01_01():
    result = parse("DPB1*348:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*348:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*348:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_348_01_02():
    result = parse("DPB1*348:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*348:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*348:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_349_01():
    result = parse("DPB1*349:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*349:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*349:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_34_01_01_01():
    result = parse("DPB1*34:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*34:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*34:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_34_01_01_02():
    result = parse("DPB1*34:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*34:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*34:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_34_01_01_03():
    result = parse("DPB1*34:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*34:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*34:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_34_01_02():
    result = parse("DPB1*34:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*34:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*34:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_350_01():
    result = parse("DPB1*350:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*350:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*350:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_351_01():
    result = parse("DPB1*351:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*351:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*351:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_352_01_01():
    result = parse("DPB1*352:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*352:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*352:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_352_01_02():
    result = parse("DPB1*352:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*352:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*352:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_353_01():
    result = parse("DPB1*353:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*353:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*353:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_354_01_01():
    result = parse("DPB1*354:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*354:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*354:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_354_01_02():
    result = parse("DPB1*354:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*354:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*354:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_355_01():
    result = parse("DPB1*355:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*355:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*355:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_356_01():
    result = parse("DPB1*356:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*356:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*356:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_357_01N():
    result = parse("DPB1*357:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*357:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*357:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_358_01():
    result = parse("DPB1*358:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*358:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*358:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_359_01():
    result = parse("DPB1*359:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*359:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*359:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_35_01_01():
    result = parse("DPB1*35:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*35:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*35:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_360_01():
    result = parse("DPB1*360:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*360:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*360:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_361_01():
    result = parse("DPB1*361:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*361:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*361:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_362_01():
    result = parse("DPB1*362:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*362:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*362:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_363_01():
    result = parse("DPB1*363:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*363:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*363:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_364_01():
    result = parse("DPB1*364:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*364:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*364:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_365_01():
    result = parse("DPB1*365:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*365:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*365:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_366_01():
    result = parse("DPB1*366:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*366:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*366:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_367_01():
    result = parse("DPB1*367:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*367:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*367:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_368_01():
    result = parse("DPB1*368:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*368:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*368:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_369_01():
    result = parse("DPB1*369:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*369:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*369:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_36_01():
    result = parse("DPB1*36:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*36:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*36:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_370_01():
    result = parse("DPB1*370:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*370:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*370:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_371_01():
    result = parse("DPB1*371:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*371:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*371:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_372_01():
    result = parse("DPB1*372:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*372:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*372:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_373_01():
    result = parse("DPB1*373:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*373:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*373:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_374_01():
    result = parse("DPB1*374:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*374:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*374:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_375_01():
    result = parse("DPB1*375:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*375:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*375:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_376_01():
    result = parse("DPB1*376:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*376:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*376:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_377_01():
    result = parse("DPB1*377:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*377:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*377:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_378_01():
    result = parse("DPB1*378:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*378:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*378:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_379_01():
    result = parse("DPB1*379:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*379:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*379:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_37_01():
    result = parse("DPB1*37:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*37:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*37:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_380_01():
    result = parse("DPB1*380:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*380:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*380:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_381_01():
    result = parse("DPB1*381:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*381:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*381:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_382_01N():
    result = parse("DPB1*382:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*382:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*382:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_383_01():
    result = parse("DPB1*383:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*383:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*383:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_384_01():
    result = parse("DPB1*384:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*384:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*384:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_385_01():
    result = parse("DPB1*385:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*385:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*385:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_386_01():
    result = parse("DPB1*386:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*386:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*386:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_387_01():
    result = parse("DPB1*387:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*387:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*387:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_388_01():
    result = parse("DPB1*388:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*388:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*388:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_389_01():
    result = parse("DPB1*389:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*389:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*389:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_38_01():
    result = parse("DPB1*38:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*38:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*38:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_390_01():
    result = parse("DPB1*390:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*390:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*390:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_391_01():
    result = parse("DPB1*391:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*391:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*391:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_392_01():
    result = parse("DPB1*392:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*392:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*392:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_393_01():
    result = parse("DPB1*393:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*393:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*393:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_394_01():
    result = parse("DPB1*394:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*394:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*394:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_395_01():
    result = parse("DPB1*395:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*395:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*395:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_396_01():
    result = parse("DPB1*396:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*396:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*396:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_397_01():
    result = parse("DPB1*397:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*397:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*397:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_398_01():
    result = parse("DPB1*398:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*398:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*398:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_399_01():
    result = parse("DPB1*399:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*399:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*399:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_39_01_01_01():
    result = parse("DPB1*39:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*39:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*39:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_39_01_01_02():
    result = parse("DPB1*39:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*39:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*39:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_39_01_01_03():
    result = parse("DPB1*39:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*39:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*39:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_39_01_01_04():
    result = parse("DPB1*39:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*39:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*39:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_39_01_02():
    result = parse("DPB1*39:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*39:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*39:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_39_01_03():
    result = parse("DPB1*39:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*39:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*39:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_400_01():
    result = parse("DPB1*400:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*400:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*400:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_401_01N():
    result = parse("DPB1*401:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*401:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*401:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_402_01():
    result = parse("DPB1*402:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*402:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*402:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_403_01N():
    result = parse("DPB1*403:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*403:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*403:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_404_01():
    result = parse("DPB1*404:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*404:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*404:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_405_01():
    result = parse("DPB1*405:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*405:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*405:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_406_01():
    result = parse("DPB1*406:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*406:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*406:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_407_01():
    result = parse("DPB1*407:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*407:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*407:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_408_01():
    result = parse("DPB1*408:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*408:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*408:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_409_01():
    result = parse("DPB1*409:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*409:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*409:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_40_01_01_01():
    result = parse("DPB1*40:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*40:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*40:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_40_01_01_02():
    result = parse("DPB1*40:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*40:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*40:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_40_01_01_03():
    result = parse("DPB1*40:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*40:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*40:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_40_01_02():
    result = parse("DPB1*40:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*40:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*40:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_410_01():
    result = parse("DPB1*410:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*410:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*410:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_411_01():
    result = parse("DPB1*411:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*411:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*411:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_412_01():
    result = parse("DPB1*412:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*412:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*412:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_413_01():
    result = parse("DPB1*413:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*413:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*413:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_414_01_01_01():
    result = parse("DPB1*414:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*414:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*414:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_414_01_01_02():
    result = parse("DPB1*414:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*414:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*414:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_415_01():
    result = parse("DPB1*415:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*415:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*415:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_416_01_01_01():
    result = parse("DPB1*416:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*416:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*416:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_416_01_01_02():
    result = parse("DPB1*416:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*416:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*416:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_416_01_01_03():
    result = parse("DPB1*416:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*416:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*416:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_416_01_02():
    result = parse("DPB1*416:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*416:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*416:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_417_01_01():
    result = parse("DPB1*417:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*417:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*417:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_417_01_02():
    result = parse("DPB1*417:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*417:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*417:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_418_01():
    result = parse("DPB1*418:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*418:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*418:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_419_01():
    result = parse("DPB1*419:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*419:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*419:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_41_01_01_01():
    result = parse("DPB1*41:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*41:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*41:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_41_01_01_02():
    result = parse("DPB1*41:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*41:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*41:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_41_01_02():
    result = parse("DPB1*41:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*41:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*41:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_420_01():
    result = parse("DPB1*420:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*420:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*420:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_421_01():
    result = parse("DPB1*421:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*421:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*421:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_422_01():
    result = parse("DPB1*422:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*422:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*422:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_423_01_01():
    result = parse("DPB1*423:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*423:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*423:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_423_01_02():
    result = parse("DPB1*423:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*423:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*423:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_424_01():
    result = parse("DPB1*424:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*424:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*424:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_425_01():
    result = parse("DPB1*425:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*425:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*425:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_426_01():
    result = parse("DPB1*426:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*426:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*426:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_427_01():
    result = parse("DPB1*427:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*427:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*427:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_428_01():
    result = parse("DPB1*428:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*428:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*428:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_429_01():
    result = parse("DPB1*429:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*429:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*429:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_430_01():
    result = parse("DPB1*430:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*430:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*430:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_431_01():
    result = parse("DPB1*431:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*431:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*431:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_432_01():
    result = parse("DPB1*432:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*432:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*432:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_433_01():
    result = parse("DPB1*433:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*433:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*433:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_434_01():
    result = parse("DPB1*434:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*434:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*434:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_435_01():
    result = parse("DPB1*435:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*435:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*435:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_436_01():
    result = parse("DPB1*436:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*436:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*436:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_437_01():
    result = parse("DPB1*437:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*437:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*437:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_438_01():
    result = parse("DPB1*438:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*438:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*438:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_439_01():
    result = parse("DPB1*439:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*439:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*439:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_440_01():
    result = parse("DPB1*440:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*440:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*440:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_441_01():
    result = parse("DPB1*441:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*441:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*441:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_442_01():
    result = parse("DPB1*442:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*442:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*442:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_443_01():
    result = parse("DPB1*443:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*443:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*443:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_444_01():
    result = parse("DPB1*444:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*444:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*444:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_445_01():
    result = parse("DPB1*445:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*445:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*445:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_446_01():
    result = parse("DPB1*446:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*446:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*446:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_447_01():
    result = parse("DPB1*447:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*447:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*447:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_448_01():
    result = parse("DPB1*448:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*448:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*448:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_449_01():
    result = parse("DPB1*449:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*449:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*449:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_44_01():
    result = parse("DPB1*44:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*44:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*44:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_450_01N():
    result = parse("DPB1*450:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*450:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*450:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_451_01():
    result = parse("DPB1*451:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*451:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*451:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_452_01():
    result = parse("DPB1*452:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*452:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*452:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_453_01():
    result = parse("DPB1*453:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*453:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*453:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_454_01():
    result = parse("DPB1*454:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*454:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*454:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_455_01N():
    result = parse("DPB1*455:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*455:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*455:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_456_01():
    result = parse("DPB1*456:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*456:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*456:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_457_01():
    result = parse("DPB1*457:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*457:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*457:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_458_01_01():
    result = parse("DPB1*458:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*458:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*458:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_458_01_02():
    result = parse("DPB1*458:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*458:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*458:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_459_01():
    result = parse("DPB1*459:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*459:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*459:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_45_01():
    result = parse("DPB1*45:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*45:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*45:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_460_01():
    result = parse("DPB1*460:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*460:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*460:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_461_01():
    result = parse("DPB1*461:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*461:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*461:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_462_01():
    result = parse("DPB1*462:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*462:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*462:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_463_01_01_01():
    result = parse("DPB1*463:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*463:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*463:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_463_01_01_02():
    result = parse("DPB1*463:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*463:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*463:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_463_01_01_03():
    result = parse("DPB1*463:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*463:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*463:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_464_01():
    result = parse("DPB1*464:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*464:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*464:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_465_01():
    result = parse("DPB1*465:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*465:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*465:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_466_01():
    result = parse("DPB1*466:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*466:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*466:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_467_01():
    result = parse("DPB1*467:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*467:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*467:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_468_01():
    result = parse("DPB1*468:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*468:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*468:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_469_01():
    result = parse("DPB1*469:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*469:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*469:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_46_01_01():
    result = parse("DPB1*46:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*46:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*46:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_46_01_02():
    result = parse("DPB1*46:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*46:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*46:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_470_01():
    result = parse("DPB1*470:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*470:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*470:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_471_01():
    result = parse("DPB1*471:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*471:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*471:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_472_01():
    result = parse("DPB1*472:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*472:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*472:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_473_01():
    result = parse("DPB1*473:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*473:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*473:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_474_01():
    result = parse("DPB1*474:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*474:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*474:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_475_01():
    result = parse("DPB1*475:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*475:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*475:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_476_01():
    result = parse("DPB1*476:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*476:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*476:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_477_01():
    result = parse("DPB1*477:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*477:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*477:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_478_01():
    result = parse("DPB1*478:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*478:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*478:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_479_01():
    result = parse("DPB1*479:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*479:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*479:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_47_01_01_01():
    result = parse("DPB1*47:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*47:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*47:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_47_01_01_02():
    result = parse("DPB1*47:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*47:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*47:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_47_01_01_03():
    result = parse("DPB1*47:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*47:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*47:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_480_01():
    result = parse("DPB1*480:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*480:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*480:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_481_01():
    result = parse("DPB1*481:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*481:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*481:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_482_01():
    result = parse("DPB1*482:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*482:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*482:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_483_01():
    result = parse("DPB1*483:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*483:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*483:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_484_01():
    result = parse("DPB1*484:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*484:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*484:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_485_01():
    result = parse("DPB1*485:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*485:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*485:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_486_01():
    result = parse("DPB1*486:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*486:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*486:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_487_01():
    result = parse("DPB1*487:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*487:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*487:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_488_01():
    result = parse("DPB1*488:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*488:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*488:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_489_01():
    result = parse("DPB1*489:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*489:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*489:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_48_01():
    result = parse("DPB1*48:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*48:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*48:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_490_01():
    result = parse("DPB1*490:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*490:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*490:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_491_01():
    result = parse("DPB1*491:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*491:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*491:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_492_01():
    result = parse("DPB1*492:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*492:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*492:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_493_01():
    result = parse("DPB1*493:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*493:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*493:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_494_01():
    result = parse("DPB1*494:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*494:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*494:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_495_01():
    result = parse("DPB1*495:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*495:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*495:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_496_01():
    result = parse("DPB1*496:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*496:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*496:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_497_01():
    result = parse("DPB1*497:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*497:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*497:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_498_01():
    result = parse("DPB1*498:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*498:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*498:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_499_01():
    result = parse("DPB1*499:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*499:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*499:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_49_01_01_01():
    result = parse("DPB1*49:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*49:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*49:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_49_01_01_02():
    result = parse("DPB1*49:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*49:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*49:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_49_01_01_03():
    result = parse("DPB1*49:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*49:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*49:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_500_01():
    result = parse("DPB1*500:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*500:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*500:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_501_01():
    result = parse("DPB1*501:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*501:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*501:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_502_01():
    result = parse("DPB1*502:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*502:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*502:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_503_01():
    result = parse("DPB1*503:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*503:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*503:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_504_01():
    result = parse("DPB1*504:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*504:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*504:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_505_01():
    result = parse("DPB1*505:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*505:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*505:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_506_01():
    result = parse("DPB1*506:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*506:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*506:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_507_01N():
    result = parse("DPB1*507:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*507:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*507:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_508_01():
    result = parse("DPB1*508:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*508:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*508:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_509_01():
    result = parse("DPB1*509:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*509:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*509:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_50_01():
    result = parse("DPB1*50:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*50:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*50:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_510_01():
    result = parse("DPB1*510:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*510:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*510:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_511_01():
    result = parse("DPB1*511:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*511:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*511:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_512_01():
    result = parse("DPB1*512:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*512:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*512:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_513_01():
    result = parse("DPB1*513:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*513:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*513:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_514_01():
    result = parse("DPB1*514:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*514:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*514:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_515_01():
    result = parse("DPB1*515:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*515:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*515:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_516_01():
    result = parse("DPB1*516:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*516:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*516:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_517_01():
    result = parse("DPB1*517:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*517:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*517:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_518_01():
    result = parse("DPB1*518:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*518:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*518:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_519_01():
    result = parse("DPB1*519:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*519:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*519:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_51_01_01_01():
    result = parse("DPB1*51:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*51:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*51:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_51_01_01_02():
    result = parse("DPB1*51:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*51:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*51:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_520_01():
    result = parse("DPB1*520:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*520:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*520:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_521_01():
    result = parse("DPB1*521:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*521:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*521:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_522_01():
    result = parse("DPB1*522:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*522:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*522:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_523_01_01():
    result = parse("DPB1*523:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*523:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*523:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_523_01_02():
    result = parse("DPB1*523:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*523:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*523:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_524_01():
    result = parse("DPB1*524:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*524:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*524:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_525_01():
    result = parse("DPB1*525:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*525:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*525:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_526_01():
    result = parse("DPB1*526:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*526:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*526:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_527_01():
    result = parse("DPB1*527:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*527:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*527:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_528_01():
    result = parse("DPB1*528:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*528:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*528:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_529_01():
    result = parse("DPB1*529:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*529:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*529:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_52_01():
    result = parse("DPB1*52:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*52:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*52:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_530_01():
    result = parse("DPB1*530:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*530:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*530:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_531_01():
    result = parse("DPB1*531:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*531:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*531:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_532_01():
    result = parse("DPB1*532:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*532:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*532:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_533_01():
    result = parse("DPB1*533:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*533:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*533:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_534_01():
    result = parse("DPB1*534:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*534:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*534:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_535_01():
    result = parse("DPB1*535:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*535:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*535:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_536_01():
    result = parse("DPB1*536:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*536:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*536:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_537_01():
    result = parse("DPB1*537:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*537:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*537:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_538_01():
    result = parse("DPB1*538:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*538:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*538:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_539_01():
    result = parse("DPB1*539:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*539:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*539:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_53_01():
    result = parse("DPB1*53:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*53:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*53:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_540_01():
    result = parse("DPB1*540:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*540:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*540:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_541_01():
    result = parse("DPB1*541:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*541:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*541:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_542_01():
    result = parse("DPB1*542:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*542:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*542:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_543_01():
    result = parse("DPB1*543:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*543:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*543:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_544_01():
    result = parse("DPB1*544:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*544:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*544:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_545_01():
    result = parse("DPB1*545:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*545:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*545:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_546_01():
    result = parse("DPB1*546:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*546:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*546:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_547_01():
    result = parse("DPB1*547:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*547:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*547:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_548_01():
    result = parse("DPB1*548:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*548:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*548:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_549_01():
    result = parse("DPB1*549:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*549:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*549:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_54_01():
    result = parse("DPB1*54:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*54:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*54:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_550_01():
    result = parse("DPB1*550:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*550:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*550:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_551_01N():
    result = parse("DPB1*551:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*551:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*551:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_552_01():
    result = parse("DPB1*552:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*552:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*552:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_553_01():
    result = parse("DPB1*553:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*553:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*553:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_554_01():
    result = parse("DPB1*554:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*554:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*554:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_555_01():
    result = parse("DPB1*555:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*555:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*555:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_556_01():
    result = parse("DPB1*556:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*556:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*556:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_557_01():
    result = parse("DPB1*557:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*557:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*557:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_558_01():
    result = parse("DPB1*558:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*558:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*558:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_559_01():
    result = parse("DPB1*559:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*559:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*559:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_55_01_01_01():
    result = parse("DPB1*55:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*55:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*55:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_55_01_01_02():
    result = parse("DPB1*55:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*55:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*55:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_55_01_01_03():
    result = parse("DPB1*55:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*55:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*55:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_55_01_01_04():
    result = parse("DPB1*55:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*55:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*55:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_55_01_01_05():
    result = parse("DPB1*55:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*55:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*55:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_55_01_02():
    result = parse("DPB1*55:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*55:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*55:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_55_01_03():
    result = parse("DPB1*55:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*55:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*55:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_560_01():
    result = parse("DPB1*560:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*560:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*560:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_561_01():
    result = parse("DPB1*561:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*561:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*561:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_562_01():
    result = parse("DPB1*562:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*562:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*562:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_563_01():
    result = parse("DPB1*563:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*563:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*563:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_564_01():
    result = parse("DPB1*564:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*564:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*564:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_565_01():
    result = parse("DPB1*565:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*565:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*565:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_566_01():
    result = parse("DPB1*566:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*566:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*566:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_567_01():
    result = parse("DPB1*567:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*567:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*567:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_568_01():
    result = parse("DPB1*568:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*568:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*568:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_569_01():
    result = parse("DPB1*569:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*569:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*569:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_56_01():
    result = parse("DPB1*56:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*56:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*56:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_570_01N():
    result = parse("DPB1*570:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*570:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*570:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_571_01():
    result = parse("DPB1*571:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*571:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*571:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_572_01():
    result = parse("DPB1*572:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*572:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*572:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_573_01():
    result = parse("DPB1*573:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*573:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*573:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_574_01():
    result = parse("DPB1*574:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*574:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*574:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_575_01():
    result = parse("DPB1*575:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*575:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*575:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_576_01():
    result = parse("DPB1*576:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*576:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*576:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_577_01():
    result = parse("DPB1*577:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*577:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*577:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_578_01():
    result = parse("DPB1*578:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*578:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*578:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_579_01():
    result = parse("DPB1*579:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*579:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*579:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_57_01():
    result = parse("DPB1*57:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*57:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*57:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_580_01():
    result = parse("DPB1*580:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*580:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*580:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_581_01():
    result = parse("DPB1*581:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*581:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*581:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_582_01():
    result = parse("DPB1*582:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*582:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*582:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_583_01():
    result = parse("DPB1*583:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*583:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*583:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_584_01_01_01():
    result = parse("DPB1*584:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*584:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*584:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_584_01_01_02():
    result = parse("DPB1*584:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*584:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*584:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_584_01_01_03():
    result = parse("DPB1*584:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*584:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*584:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_584_01_02_01():
    result = parse("DPB1*584:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*584:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*584:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_584_01_02_02():
    result = parse("DPB1*584:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*584:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*584:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_585_01_01_01():
    result = parse("DPB1*585:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*585:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*585:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_585_01_01_02():
    result = parse("DPB1*585:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*585:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*585:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_586_01():
    result = parse("DPB1*586:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*586:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*586:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_587_01():
    result = parse("DPB1*587:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*587:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*587:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_588_01():
    result = parse("DPB1*588:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*588:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*588:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_589_01():
    result = parse("DPB1*589:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*589:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*589:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_58_01():
    result = parse("DPB1*58:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*58:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*58:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_590_01():
    result = parse("DPB1*590:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*590:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*590:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_591_01():
    result = parse("DPB1*591:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*591:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*591:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_592_01():
    result = parse("DPB1*592:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*592:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*592:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_593_01():
    result = parse("DPB1*593:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*593:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*593:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_594_01():
    result = parse("DPB1*594:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*594:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*594:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_595_01():
    result = parse("DPB1*595:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*595:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*595:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_596_01():
    result = parse("DPB1*596:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*596:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*596:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_597_01():
    result = parse("DPB1*597:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*597:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*597:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_598_01N():
    result = parse("DPB1*598:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*598:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*598:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_599_01():
    result = parse("DPB1*599:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*599:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*599:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_59_01():
    result = parse("DPB1*59:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*59:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*59:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_600_01():
    result = parse("DPB1*600:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*600:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*600:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_601_01():
    result = parse("DPB1*601:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*601:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*601:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_602_01():
    result = parse("DPB1*602:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*602:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*602:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_603_01():
    result = parse("DPB1*603:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*603:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*603:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_604_01():
    result = parse("DPB1*604:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*604:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*604:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_605_01():
    result = parse("DPB1*605:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*605:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*605:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_606_01():
    result = parse("DPB1*606:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*606:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*606:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_607_01():
    result = parse("DPB1*607:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*607:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*607:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_608_01():
    result = parse("DPB1*608:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*608:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*608:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_609_01():
    result = parse("DPB1*609:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*609:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*609:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_60_01():
    result = parse("DPB1*60:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*60:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*60:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_610_01():
    result = parse("DPB1*610:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*610:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*610:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_611_01():
    result = parse("DPB1*611:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*611:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*611:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_612_01():
    result = parse("DPB1*612:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*612:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*612:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_613_01():
    result = parse("DPB1*613:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*613:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*613:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_614_01():
    result = parse("DPB1*614:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*614:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*614:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_615_01():
    result = parse("DPB1*615:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*615:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*615:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_616_01():
    result = parse("DPB1*616:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*616:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*616:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_617_01():
    result = parse("DPB1*617:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*617:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*617:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_618_01():
    result = parse("DPB1*618:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*618:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*618:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_619_01():
    result = parse("DPB1*619:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*619:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*619:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_61_01N():
    result = parse("DPB1*61:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*61:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*61:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_620_01():
    result = parse("DPB1*620:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*620:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*620:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_621_01():
    result = parse("DPB1*621:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*621:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*621:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_622_01():
    result = parse("DPB1*622:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*622:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*622:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_623_01():
    result = parse("DPB1*623:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*623:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*623:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_624_01():
    result = parse("DPB1*624:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*624:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*624:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_625_01():
    result = parse("DPB1*625:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*625:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*625:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_626_01():
    result = parse("DPB1*626:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*626:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*626:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_627_01():
    result = parse("DPB1*627:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*627:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*627:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_628_01():
    result = parse("DPB1*628:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*628:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*628:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_629_01():
    result = parse("DPB1*629:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*629:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*629:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_62_01():
    result = parse("DPB1*62:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*62:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*62:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_630_01():
    result = parse("DPB1*630:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*630:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*630:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_631_01():
    result = parse("DPB1*631:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*631:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*631:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_632_01():
    result = parse("DPB1*632:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*632:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*632:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_633_01():
    result = parse("DPB1*633:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*633:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*633:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_634_01():
    result = parse("DPB1*634:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*634:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*634:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_635_01():
    result = parse("DPB1*635:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*635:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*635:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_636_01():
    result = parse("DPB1*636:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*636:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*636:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_637_01():
    result = parse("DPB1*637:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*637:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*637:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_638_01():
    result = parse("DPB1*638:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*638:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*638:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_639_01():
    result = parse("DPB1*639:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*639:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*639:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_63_01():
    result = parse("DPB1*63:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*63:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*63:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_640_01():
    result = parse("DPB1*640:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*640:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*640:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_641_01():
    result = parse("DPB1*641:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*641:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*641:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_642_01():
    result = parse("DPB1*642:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*642:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*642:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_643_01():
    result = parse("DPB1*643:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*643:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*643:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_644_01():
    result = parse("DPB1*644:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*644:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*644:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_645_01():
    result = parse("DPB1*645:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*645:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*645:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_646_01():
    result = parse("DPB1*646:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*646:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*646:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_647_01():
    result = parse("DPB1*647:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*647:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*647:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_648_01_01_01():
    result = parse("DPB1*648:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*648:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*648:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_648_01_01_02():
    result = parse("DPB1*648:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*648:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*648:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_649_01():
    result = parse("DPB1*649:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*649:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*649:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_64_01N():
    result = parse("DPB1*64:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*64:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*64:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_650_01():
    result = parse("DPB1*650:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*650:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*650:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_651_01():
    result = parse("DPB1*651:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*651:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*651:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_652_01():
    result = parse("DPB1*652:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*652:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*652:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_653_01():
    result = parse("DPB1*653:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*653:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*653:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_654_01():
    result = parse("DPB1*654:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*654:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*654:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_655_01():
    result = parse("DPB1*655:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*655:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*655:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_656_01():
    result = parse("DPB1*656:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*656:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*656:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_657_01N():
    result = parse("DPB1*657:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*657:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*657:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_658_01():
    result = parse("DPB1*658:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*658:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*658:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_659_01():
    result = parse("DPB1*659:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*659:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*659:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_65_01_01():
    result = parse("DPB1*65:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*65:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*65:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_65_01_02():
    result = parse("DPB1*65:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*65:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*65:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_660_01():
    result = parse("DPB1*660:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*660:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*660:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_661_01N():
    result = parse("DPB1*661:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*661:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*661:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_662_01():
    result = parse("DPB1*662:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*662:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*662:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_663_01():
    result = parse("DPB1*663:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*663:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*663:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_664_01():
    result = parse("DPB1*664:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*664:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*664:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_665_01():
    result = parse("DPB1*665:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*665:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*665:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_666_01():
    result = parse("DPB1*666:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*666:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*666:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_667_01():
    result = parse("DPB1*667:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*667:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*667:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_668_01_01_01():
    result = parse("DPB1*668:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*668:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*668:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_668_01_01_02():
    result = parse("DPB1*668:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*668:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*668:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_669_01():
    result = parse("DPB1*669:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*669:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*669:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_66_01():
    result = parse("DPB1*66:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*66:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*66:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_670_01():
    result = parse("DPB1*670:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*670:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*670:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_671_01():
    result = parse("DPB1*671:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*671:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*671:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_672_01():
    result = parse("DPB1*672:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*672:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*672:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_673_01():
    result = parse("DPB1*673:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*673:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*673:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_674_01():
    result = parse("DPB1*674:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*674:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*674:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_675_01():
    result = parse("DPB1*675:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*675:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*675:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_676_01():
    result = parse("DPB1*676:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*676:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*676:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_677_01():
    result = parse("DPB1*677:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*677:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*677:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_678_01():
    result = parse("DPB1*678:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*678:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*678:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_679_01():
    result = parse("DPB1*679:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*679:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*679:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_67_01():
    result = parse("DPB1*67:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*67:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*67:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_680_01():
    result = parse("DPB1*680:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*680:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*680:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_681_01():
    result = parse("DPB1*681:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*681:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*681:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_682_01():
    result = parse("DPB1*682:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*682:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*682:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_683_01():
    result = parse("DPB1*683:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*683:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*683:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_684_01():
    result = parse("DPB1*684:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*684:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*684:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_685_01():
    result = parse("DPB1*685:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*685:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*685:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_686_01():
    result = parse("DPB1*686:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*686:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*686:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_687_01():
    result = parse("DPB1*687:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*687:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*687:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_688_01():
    result = parse("DPB1*688:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*688:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*688:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_689_01():
    result = parse("DPB1*689:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*689:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*689:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_68_01():
    result = parse("DPB1*68:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*68:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*68:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_690_01():
    result = parse("DPB1*690:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*690:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*690:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_691_01N():
    result = parse("DPB1*691:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*691:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*691:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_692_01():
    result = parse("DPB1*692:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*692:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*692:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_693_01N():
    result = parse("DPB1*693:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*693:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*693:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_694_01():
    result = parse("DPB1*694:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*694:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*694:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_695_01():
    result = parse("DPB1*695:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*695:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*695:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_696_01N():
    result = parse("DPB1*696:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*696:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*696:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_697_01Q():
    result = parse("DPB1*697:01Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*697:01Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*697:01Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_698_01():
    result = parse("DPB1*698:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*698:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*698:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_699_01():
    result = parse("DPB1*699:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*699:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*699:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_69_01_01_01():
    result = parse("DPB1*69:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*69:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*69:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_69_01_01_02():
    result = parse("DPB1*69:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*69:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*69:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_700_01N():
    result = parse("DPB1*700:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*700:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*700:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_701_01():
    result = parse("DPB1*701:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*701:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*701:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_702_01():
    result = parse("DPB1*702:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*702:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*702:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_703_01():
    result = parse("DPB1*703:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*703:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*703:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_704_01():
    result = parse("DPB1*704:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*704:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*704:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_705_01():
    result = parse("DPB1*705:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*705:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*705:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_706_01():
    result = parse("DPB1*706:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*706:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*706:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_707_01():
    result = parse("DPB1*707:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*707:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*707:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_708_01():
    result = parse("DPB1*708:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*708:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*708:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_709_01():
    result = parse("DPB1*709:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*709:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*709:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_70_01():
    result = parse("DPB1*70:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*70:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*70:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_710_01():
    result = parse("DPB1*710:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*710:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*710:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_711_01():
    result = parse("DPB1*711:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*711:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*711:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_712_01N():
    result = parse("DPB1*712:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*712:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*712:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_713_01():
    result = parse("DPB1*713:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*713:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*713:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_714_01():
    result = parse("DPB1*714:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*714:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*714:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_715_01():
    result = parse("DPB1*715:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*715:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*715:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_716_01():
    result = parse("DPB1*716:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*716:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*716:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_717_01():
    result = parse("DPB1*717:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*717:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*717:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_718_01():
    result = parse("DPB1*718:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*718:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*718:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_719_01():
    result = parse("DPB1*719:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*719:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*719:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_71_01_01():
    result = parse("DPB1*71:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*71:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*71:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_71_01_02():
    result = parse("DPB1*71:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*71:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*71:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_720_01():
    result = parse("DPB1*720:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*720:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*720:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_721_01():
    result = parse("DPB1*721:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*721:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*721:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_722_01():
    result = parse("DPB1*722:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*722:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*722:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_723_01():
    result = parse("DPB1*723:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*723:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*723:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_724_01N():
    result = parse("DPB1*724:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*724:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*724:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_725_01():
    result = parse("DPB1*725:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*725:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*725:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_726_01():
    result = parse("DPB1*726:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*726:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*726:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_727_01():
    result = parse("DPB1*727:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*727:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*727:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_728_01():
    result = parse("DPB1*728:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*728:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*728:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_729_01():
    result = parse("DPB1*729:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*729:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*729:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_72_01_01_01():
    result = parse("DPB1*72:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*72:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*72:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_72_01_01_02():
    result = parse("DPB1*72:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*72:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*72:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_72_01_01_03():
    result = parse("DPB1*72:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*72:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*72:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_730_01():
    result = parse("DPB1*730:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*730:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*730:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_731_01():
    result = parse("DPB1*731:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*731:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*731:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_732_01N():
    result = parse("DPB1*732:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*732:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*732:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_733_01():
    result = parse("DPB1*733:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*733:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*733:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_734_01():
    result = parse("DPB1*734:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*734:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*734:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_735_01():
    result = parse("DPB1*735:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*735:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*735:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_736_01():
    result = parse("DPB1*736:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*736:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*736:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_737_01():
    result = parse("DPB1*737:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*737:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*737:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_738_01N():
    result = parse("DPB1*738:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*738:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*738:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_739_01():
    result = parse("DPB1*739:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*739:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*739:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_73_01():
    result = parse("DPB1*73:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*73:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*73:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_740_01():
    result = parse("DPB1*740:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*740:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*740:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_741_01():
    result = parse("DPB1*741:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*741:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*741:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_742_01():
    result = parse("DPB1*742:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*742:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*742:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_743_01N():
    result = parse("DPB1*743:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*743:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*743:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_744_01():
    result = parse("DPB1*744:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*744:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*744:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_745_01():
    result = parse("DPB1*745:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*745:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*745:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_746_01():
    result = parse("DPB1*746:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*746:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*746:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_747_01():
    result = parse("DPB1*747:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*747:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*747:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_748_01N():
    result = parse("DPB1*748:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*748:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*748:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_749_01():
    result = parse("DPB1*749:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*749:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*749:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_74_01():
    result = parse("DPB1*74:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*74:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*74:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_750_01():
    result = parse("DPB1*750:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*750:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*750:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_751_01():
    result = parse("DPB1*751:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*751:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*751:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_752_01():
    result = parse("DPB1*752:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*752:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*752:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_753_01():
    result = parse("DPB1*753:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*753:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*753:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_754_01N():
    result = parse("DPB1*754:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*754:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*754:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_755_01():
    result = parse("DPB1*755:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*755:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*755:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_756_01N():
    result = parse("DPB1*756:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*756:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*756:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_757_01():
    result = parse("DPB1*757:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*757:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*757:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_758_01():
    result = parse("DPB1*758:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*758:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*758:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_759_01():
    result = parse("DPB1*759:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*759:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*759:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_75_01():
    result = parse("DPB1*75:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*75:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*75:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_760_01():
    result = parse("DPB1*760:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*760:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*760:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_761_01():
    result = parse("DPB1*761:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*761:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*761:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_762_01():
    result = parse("DPB1*762:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*762:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*762:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_763_01():
    result = parse("DPB1*763:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*763:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*763:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_764_01():
    result = parse("DPB1*764:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*764:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*764:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_765_01():
    result = parse("DPB1*765:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*765:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*765:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_766_01():
    result = parse("DPB1*766:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*766:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*766:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_767_01():
    result = parse("DPB1*767:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*767:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*767:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_768_01():
    result = parse("DPB1*768:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*768:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*768:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_769_01():
    result = parse("DPB1*769:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*769:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*769:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_76_01():
    result = parse("DPB1*76:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*76:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*76:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_770_01():
    result = parse("DPB1*770:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*770:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*770:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_771_01():
    result = parse("DPB1*771:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*771:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*771:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_772_01():
    result = parse("DPB1*772:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*772:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*772:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_773_01():
    result = parse("DPB1*773:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*773:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*773:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_774_01():
    result = parse("DPB1*774:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*774:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*774:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_775_01():
    result = parse("DPB1*775:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*775:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*775:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_776_01():
    result = parse("DPB1*776:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*776:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*776:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_777_01N():
    result = parse("DPB1*777:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*777:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*777:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_778_01():
    result = parse("DPB1*778:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*778:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*778:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_779_01():
    result = parse("DPB1*779:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*779:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*779:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_77_01():
    result = parse("DPB1*77:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*77:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*77:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_780_01():
    result = parse("DPB1*780:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*780:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*780:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_781_01():
    result = parse("DPB1*781:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*781:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*781:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_782_01():
    result = parse("DPB1*782:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*782:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*782:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_783_01():
    result = parse("DPB1*783:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*783:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*783:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_784_01():
    result = parse("DPB1*784:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*784:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*784:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_785_01():
    result = parse("DPB1*785:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*785:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*785:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_786_01_01N():
    result = parse("DPB1*786:01:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*786:01:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*786:01:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_786_01_02N():
    result = parse("DPB1*786:01:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*786:01:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*786:01:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_787_01():
    result = parse("DPB1*787:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*787:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*787:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_788_01():
    result = parse("DPB1*788:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*788:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*788:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_789_01():
    result = parse("DPB1*789:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*789:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*789:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_78_01():
    result = parse("DPB1*78:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*78:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*78:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_790_01():
    result = parse("DPB1*790:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*790:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*790:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_791_01():
    result = parse("DPB1*791:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*791:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*791:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_792_01N():
    result = parse("DPB1*792:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*792:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*792:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_794_01N():
    result = parse("DPB1*794:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*794:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*794:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_795_01():
    result = parse("DPB1*795:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*795:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*795:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_796_01():
    result = parse("DPB1*796:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*796:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*796:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_797_01():
    result = parse("DPB1*797:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*797:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*797:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_798_01():
    result = parse("DPB1*798:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*798:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*798:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_799_01():
    result = parse("DPB1*799:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*799:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*799:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_79_01():
    result = parse("DPB1*79:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*79:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*79:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_800_01N():
    result = parse("DPB1*800:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*800:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*800:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_801_01():
    result = parse("DPB1*801:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*801:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*801:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_802_01():
    result = parse("DPB1*802:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*802:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*802:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_803_01():
    result = parse("DPB1*803:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*803:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*803:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_804_01():
    result = parse("DPB1*804:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*804:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*804:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_805_01():
    result = parse("DPB1*805:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*805:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*805:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_806_01_01_01():
    result = parse("DPB1*806:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*806:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*806:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_806_01_01_02():
    result = parse("DPB1*806:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*806:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*806:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_807_01():
    result = parse("DPB1*807:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*807:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*807:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_808_01():
    result = parse("DPB1*808:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*808:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*808:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_809_01():
    result = parse("DPB1*809:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*809:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*809:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_80_01():
    result = parse("DPB1*80:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*80:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*80:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_810_01():
    result = parse("DPB1*810:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*810:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*810:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_811_01():
    result = parse("DPB1*811:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*811:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*811:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_812_01():
    result = parse("DPB1*812:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*812:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*812:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_813_01():
    result = parse("DPB1*813:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*813:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*813:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_814_01():
    result = parse("DPB1*814:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*814:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*814:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_815_01():
    result = parse("DPB1*815:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*815:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*815:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_816_01():
    result = parse("DPB1*816:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*816:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*816:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_817_01():
    result = parse("DPB1*817:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*817:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*817:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_818_01():
    result = parse("DPB1*818:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*818:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*818:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_819_01():
    result = parse("DPB1*819:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*819:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*819:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_81_01_01_01():
    result = parse("DPB1*81:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*81:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*81:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_81_01_01_02():
    result = parse("DPB1*81:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*81:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*81:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_81_01_02():
    result = parse("DPB1*81:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*81:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*81:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_820_01():
    result = parse("DPB1*820:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*820:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*820:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_821_01N():
    result = parse("DPB1*821:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*821:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*821:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_822_01():
    result = parse("DPB1*822:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*822:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*822:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_823_01():
    result = parse("DPB1*823:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*823:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*823:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_824_01_01():
    result = parse("DPB1*824:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*824:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*824:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_824_01_02():
    result = parse("DPB1*824:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*824:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*824:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_825_01():
    result = parse("DPB1*825:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*825:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*825:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_826_01():
    result = parse("DPB1*826:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*826:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*826:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_827_01():
    result = parse("DPB1*827:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*827:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*827:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_828_01():
    result = parse("DPB1*828:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*828:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*828:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_829_01():
    result = parse("DPB1*829:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*829:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*829:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_82_01():
    result = parse("DPB1*82:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*82:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*82:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_830_01():
    result = parse("DPB1*830:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*830:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*830:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_831_01N():
    result = parse("DPB1*831:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*831:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*831:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_832_01():
    result = parse("DPB1*832:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*832:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*832:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_833_01():
    result = parse("DPB1*833:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*833:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*833:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_834_01():
    result = parse("DPB1*834:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*834:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*834:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_835_01_01_01():
    result = parse("DPB1*835:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*835:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*835:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_835_01_01_02():
    result = parse("DPB1*835:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*835:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*835:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_835_01_01_03():
    result = parse("DPB1*835:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*835:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*835:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_836_01():
    result = parse("DPB1*836:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*836:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*836:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_837_01():
    result = parse("DPB1*837:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*837:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*837:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_838_01N():
    result = parse("DPB1*838:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*838:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*838:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_839_01():
    result = parse("DPB1*839:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*839:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*839:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_83_01():
    result = parse("DPB1*83:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*83:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*83:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_840_01():
    result = parse("DPB1*840:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*840:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*840:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_841_01():
    result = parse("DPB1*841:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*841:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*841:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_842_01():
    result = parse("DPB1*842:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*842:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*842:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_843_01():
    result = parse("DPB1*843:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*843:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*843:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_844_01N():
    result = parse("DPB1*844:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*844:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*844:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_845_01():
    result = parse("DPB1*845:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*845:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*845:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_846_01():
    result = parse("DPB1*846:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*846:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*846:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_847_01():
    result = parse("DPB1*847:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*847:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*847:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_848_01():
    result = parse("DPB1*848:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*848:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*848:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_849_01():
    result = parse("DPB1*849:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*849:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*849:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_84_01():
    result = parse("DPB1*84:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*84:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*84:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_850_01():
    result = parse("DPB1*850:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*850:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*850:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_851_01():
    result = parse("DPB1*851:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*851:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*851:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_852_01():
    result = parse("DPB1*852:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*852:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*852:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_853_01():
    result = parse("DPB1*853:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*853:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*853:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_854_01():
    result = parse("DPB1*854:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*854:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*854:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_855_01():
    result = parse("DPB1*855:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*855:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*855:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_856_01():
    result = parse("DPB1*856:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*856:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*856:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_857_01():
    result = parse("DPB1*857:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*857:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*857:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_858_01():
    result = parse("DPB1*858:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*858:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*858:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_859_01():
    result = parse("DPB1*859:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*859:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*859:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_85_01_01_01():
    result = parse("DPB1*85:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*85:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*85:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_85_01_01_02():
    result = parse("DPB1*85:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*85:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*85:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_85_01_02():
    result = parse("DPB1*85:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*85:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*85:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_860_01():
    result = parse("DPB1*860:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*860:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*860:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_861_01():
    result = parse("DPB1*861:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*861:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*861:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_862_01N():
    result = parse("DPB1*862:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*862:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*862:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_863_01():
    result = parse("DPB1*863:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*863:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*863:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_864_01():
    result = parse("DPB1*864:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*864:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*864:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_865_01N():
    result = parse("DPB1*865:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*865:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*865:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_866_01N():
    result = parse("DPB1*866:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*866:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*866:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_867_01N():
    result = parse("DPB1*867:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*867:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*867:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_868_01N():
    result = parse("DPB1*868:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*868:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*868:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_869_01N():
    result = parse("DPB1*869:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*869:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*869:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_86_01():
    result = parse("DPB1*86:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*86:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*86:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_870_01N():
    result = parse("DPB1*870:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*870:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*870:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_871_01N():
    result = parse("DPB1*871:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*871:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*871:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_872_01N():
    result = parse("DPB1*872:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*872:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*872:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_873_01N():
    result = parse("DPB1*873:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*873:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*873:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_874_01N():
    result = parse("DPB1*874:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*874:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*874:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_875_01N():
    result = parse("DPB1*875:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*875:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*875:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_876_01N():
    result = parse("DPB1*876:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*876:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*876:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_877_01N():
    result = parse("DPB1*877:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*877:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*877:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_878_01N():
    result = parse("DPB1*878:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*878:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*878:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_879_01_01_01():
    result = parse("DPB1*879:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*879:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*879:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_879_01_01_02():
    result = parse("DPB1*879:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*879:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*879:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_879_01_01_03():
    result = parse("DPB1*879:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*879:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*879:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_87_01():
    result = parse("DPB1*87:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*87:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*87:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_880_01():
    result = parse("DPB1*880:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*880:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*880:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_881_01():
    result = parse("DPB1*881:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*881:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*881:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_882_01():
    result = parse("DPB1*882:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*882:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*882:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_883_01():
    result = parse("DPB1*883:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*883:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*883:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_884_01():
    result = parse("DPB1*884:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*884:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*884:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_885_01():
    result = parse("DPB1*885:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*885:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*885:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_886_01():
    result = parse("DPB1*886:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*886:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*886:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_887_01():
    result = parse("DPB1*887:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*887:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*887:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_888_01():
    result = parse("DPB1*888:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*888:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*888:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_889_01():
    result = parse("DPB1*889:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*889:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*889:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_88_01():
    result = parse("DPB1*88:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*88:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*88:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_890_01():
    result = parse("DPB1*890:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*890:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*890:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_891_01():
    result = parse("DPB1*891:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*891:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*891:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_892_01():
    result = parse("DPB1*892:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*892:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*892:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_893_01():
    result = parse("DPB1*893:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*893:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*893:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_894_01N():
    result = parse("DPB1*894:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*894:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*894:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_895_01():
    result = parse("DPB1*895:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*895:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*895:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_896_01():
    result = parse("DPB1*896:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*896:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*896:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_897_01():
    result = parse("DPB1*897:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*897:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*897:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_898_01():
    result = parse("DPB1*898:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*898:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*898:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_899_01():
    result = parse("DPB1*899:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*899:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*899:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_89_01():
    result = parse("DPB1*89:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*89:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*89:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_900_01():
    result = parse("DPB1*900:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*900:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*900:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_901_01():
    result = parse("DPB1*901:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*901:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*901:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_902_01():
    result = parse("DPB1*902:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*902:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*902:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_903_01():
    result = parse("DPB1*903:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*903:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*903:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_904_01():
    result = parse("DPB1*904:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*904:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*904:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_905_01():
    result = parse("DPB1*905:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*905:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*905:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_906_01():
    result = parse("DPB1*906:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*906:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*906:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_907_01():
    result = parse("DPB1*907:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*907:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*907:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_908_01():
    result = parse("DPB1*908:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*908:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*908:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_909_01():
    result = parse("DPB1*909:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*909:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*909:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_90_01_01():
    result = parse("DPB1*90:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*90:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*90:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_90_01_02():
    result = parse("DPB1*90:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*90:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*90:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_910_01():
    result = parse("DPB1*910:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*910:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*910:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_911_01N():
    result = parse("DPB1*911:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*911:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*911:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_912_01():
    result = parse("DPB1*912:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*912:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*912:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_913_01():
    result = parse("DPB1*913:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*913:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*913:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_914_01():
    result = parse("DPB1*914:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*914:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*914:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_915_01():
    result = parse("DPB1*915:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*915:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*915:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_916_01():
    result = parse("DPB1*916:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*916:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*916:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_917_01N():
    result = parse("DPB1*917:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*917:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*917:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_918_01():
    result = parse("DPB1*918:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*918:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*918:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_919_01N():
    result = parse("DPB1*919:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*919:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*919:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_91_01_01_01():
    result = parse("DPB1*91:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*91:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*91:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_91_01_01_02():
    result = parse("DPB1*91:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*91:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*91:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_91_01_02():
    result = parse("DPB1*91:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*91:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DPB1*91:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_920_01():
    result = parse("DPB1*920:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*920:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*920:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_921_01():
    result = parse("DPB1*921:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*921:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*921:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_922_01():
    result = parse("DPB1*922:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*922:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*922:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_923_01():
    result = parse("DPB1*923:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*923:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*923:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_924_01():
    result = parse("DPB1*924:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*924:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*924:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_925_01N():
    result = parse("DPB1*925:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*925:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*925:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_926_01():
    result = parse("DPB1*926:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*926:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*926:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_927_01():
    result = parse("DPB1*927:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*927:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*927:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_928_01():
    result = parse("DPB1*928:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*928:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*928:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_929_01():
    result = parse("DPB1*929:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*929:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*929:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_92_01():
    result = parse("DPB1*92:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*92:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*92:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_930_01():
    result = parse("DPB1*930:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*930:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*930:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_931_01():
    result = parse("DPB1*931:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*931:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*931:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_932_01():
    result = parse("DPB1*932:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*932:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*932:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_933_01():
    result = parse("DPB1*933:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*933:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*933:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_934_01Q():
    result = parse("DPB1*934:01Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*934:01Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*934:01Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_935_01Q():
    result = parse("DPB1*935:01Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*935:01Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*935:01Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_936_01Q():
    result = parse("DPB1*936:01Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*936:01Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*936:01Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_937_01():
    result = parse("DPB1*937:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*937:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*937:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_938_01():
    result = parse("DPB1*938:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*938:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*938:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_939_01():
    result = parse("DPB1*939:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*939:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*939:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_93_01():
    result = parse("DPB1*93:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*93:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*93:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_940_01():
    result = parse("DPB1*940:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*940:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*940:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_941_01N():
    result = parse("DPB1*941:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*941:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*941:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_942_01():
    result = parse("DPB1*942:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*942:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*942:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_943_01():
    result = parse("DPB1*943:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*943:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*943:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_944_01():
    result = parse("DPB1*944:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*944:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*944:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_945_01():
    result = parse("DPB1*945:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*945:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*945:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_946_01():
    result = parse("DPB1*946:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*946:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*946:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_947_01():
    result = parse("DPB1*947:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*947:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*947:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_948_01():
    result = parse("DPB1*948:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*948:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*948:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_949_01():
    result = parse("DPB1*949:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*949:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*949:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_94_01():
    result = parse("DPB1*94:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*94:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*94:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_950_01N():
    result = parse("DPB1*950:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*950:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*950:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_951_01():
    result = parse("DPB1*951:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*951:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*951:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_952_01():
    result = parse("DPB1*952:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*952:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*952:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_953_01():
    result = parse("DPB1*953:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*953:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*953:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_954_01():
    result = parse("DPB1*954:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*954:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*954:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_955_01():
    result = parse("DPB1*955:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*955:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*955:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_956_01():
    result = parse("DPB1*956:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*956:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*956:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_957_01():
    result = parse("DPB1*957:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*957:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*957:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_958_01():
    result = parse("DPB1*958:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*958:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*958:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_959_01N():
    result = parse("DPB1*959:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*959:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*959:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_95_01():
    result = parse("DPB1*95:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*95:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*95:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_960_01N():
    result = parse("DPB1*960:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*960:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*960:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_961_01():
    result = parse("DPB1*961:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*961:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*961:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_962_01():
    result = parse("DPB1*962:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*962:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*962:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_963_01():
    result = parse("DPB1*963:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*963:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*963:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_964_01():
    result = parse("DPB1*964:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*964:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*964:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_965_01_01_01():
    result = parse("DPB1*965:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*965:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*965:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_965_01_01_02():
    result = parse("DPB1*965:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*965:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DPB1*965:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_966_01():
    result = parse("DPB1*966:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*966:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*966:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_967_01():
    result = parse("DPB1*967:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*967:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*967:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_968_01():
    result = parse("DPB1*968:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*968:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*968:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_969_01():
    result = parse("DPB1*969:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*969:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*969:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_96_01():
    result = parse("DPB1*96:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*96:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*96:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_970_01():
    result = parse("DPB1*970:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*970:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*970:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_971_01():
    result = parse("DPB1*971:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*971:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*971:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_972_01():
    result = parse("DPB1*972:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*972:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*972:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_973_01():
    result = parse("DPB1*973:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*973:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*973:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_974_01N():
    result = parse("DPB1*974:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*974:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*974:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_975_01():
    result = parse("DPB1*975:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*975:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*975:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_976_01():
    result = parse("DPB1*976:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*976:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*976:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_977_01():
    result = parse("DPB1*977:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*977:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*977:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_978_01():
    result = parse("DPB1*978:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*978:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*978:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_979_01():
    result = parse("DPB1*979:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*979:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*979:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_97_01():
    result = parse("DPB1*97:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*97:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*97:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_980_01():
    result = parse("DPB1*980:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*980:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*980:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_981_01():
    result = parse("DPB1*981:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*981:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*981:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_982_01():
    result = parse("DPB1*982:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*982:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*982:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_983_01():
    result = parse("DPB1*983:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*983:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*983:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_984_01N():
    result = parse("DPB1*984:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*984:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*984:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_985_01N():
    result = parse("DPB1*985:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*985:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*985:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_986_01N():
    result = parse("DPB1*986:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*986:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*986:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_987_01():
    result = parse("DPB1*987:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*987:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*987:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_988_01():
    result = parse("DPB1*988:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*988:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*988:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_989_01():
    result = parse("DPB1*989:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*989:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*989:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_98_01():
    result = parse("DPB1*98:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*98:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*98:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_990_01():
    result = parse("DPB1*990:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*990:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*990:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_991_01():
    result = parse("DPB1*991:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*991:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*991:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_992_01():
    result = parse("DPB1*992:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*992:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*992:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_993_01():
    result = parse("DPB1*993:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*993:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*993:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_994_01():
    result = parse("DPB1*994:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*994:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*994:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_995_01N():
    result = parse("DPB1*995:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*995:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*995:01N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_996_01():
    result = parse("DPB1*996:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*996:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*996:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_997_01():
    result = parse("DPB1*997:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*997:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*997:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_998_01():
    result = parse("DPB1*998:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*998:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*998:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_999_01():
    result = parse("DPB1*999:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DPB1*999:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*999:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DPB1_99_01():
    result = parse("DPB1*99:01")
    assert result.__class__ is Allele, f'Expected parse("DPB1*99:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DPB1*99:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_01_01_01():
    result = parse("DQA1*01:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_01_01_02():
    result = parse("DQA1*01:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_01_01_03():
    result = parse("DQA1*01:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_01_01_05():
    result = parse("DQA1*01:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_01_01_06():
    result = parse("DQA1*01:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_01_01_07():
    result = parse("DQA1*01:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_01_01_08():
    result = parse("DQA1*01:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_01_01_09():
    result = parse("DQA1*01:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_01_02_01():
    result = parse("DQA1*01:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_01_02_02():
    result = parse("DQA1*01:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_01_03():
    result = parse("DQA1*01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_01_04():
    result = parse("DQA1*01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_01_05():
    result = parse("DQA1*01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_01_06():
    result = parse("DQA1*01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_01_07():
    result = parse("DQA1*01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_01_01():
    result = parse("DQA1*01:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_01_02():
    result = parse("DQA1*01:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_01_03():
    result = parse("DQA1*01:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_01_04():
    result = parse("DQA1*01:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_01_05():
    result = parse("DQA1*01:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_01_06():
    result = parse("DQA1*01:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_01_07():
    result = parse("DQA1*01:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_01_08():
    result = parse("DQA1*01:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_01_09():
    result = parse("DQA1*01:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_01_10():
    result = parse("DQA1*01:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_01_11():
    result = parse("DQA1*01:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_01_12():
    result = parse("DQA1*01:02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_01_13():
    result = parse("DQA1*01:02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_01_14():
    result = parse("DQA1*01:02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_02_01():
    result = parse("DQA1*01:02:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_02_02():
    result = parse("DQA1*01:02:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_02_03():
    result = parse("DQA1*01:02:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_02_04():
    result = parse("DQA1*01:02:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_02_05():
    result = parse("DQA1*01:02:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:02:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_03():
    result = parse("DQA1*01:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_04():
    result = parse("DQA1*01:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_05():
    result = parse("DQA1*01:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_06():
    result = parse("DQA1*01:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_07():
    result = parse("DQA1*01:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_08():
    result = parse("DQA1*01:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_02_09():
    result = parse("DQA1*01:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_03_01_01():
    result = parse("DQA1*01:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_03_01_02():
    result = parse("DQA1*01:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_03_01_03():
    result = parse("DQA1*01:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_03_01_04():
    result = parse("DQA1*01:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_03_01_05():
    result = parse("DQA1*01:03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:03:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_03_01_06():
    result = parse("DQA1*01:03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:03:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_03_01_07():
    result = parse("DQA1*01:03:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:03:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:03:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_03_01_08():
    result = parse("DQA1*01:03:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:03:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:03:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_03_01_09():
    result = parse("DQA1*01:03:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:03:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:03:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_03_01_10():
    result = parse("DQA1*01:03:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:03:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:03:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_03_01_11():
    result = parse("DQA1*01:03:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:03:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:03:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_03_02():
    result = parse("DQA1*01:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_03_03():
    result = parse("DQA1*01:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_03_04():
    result = parse("DQA1*01:03:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:03:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_04_01_01():
    result = parse("DQA1*01:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_04_01_02():
    result = parse("DQA1*01:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_04_01_03():
    result = parse("DQA1*01:04:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:04:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:04:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_04_01_04():
    result = parse("DQA1*01:04:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:04:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:04:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_04_02():
    result = parse("DQA1*01:04:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:04:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_04_03():
    result = parse("DQA1*01:04:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:04:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_05_01_01():
    result = parse("DQA1*01:05:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:05:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:05:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_05_01_02():
    result = parse("DQA1*01:05:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:05:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:05:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_05_01_03():
    result = parse("DQA1*01:05:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:05:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:05:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_05_02():
    result = parse("DQA1*01:05:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:05:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_05_03():
    result = parse("DQA1*01:05:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:05:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*01:05:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_06():
    result = parse("DQA1*01:06")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_07Q():
    result = parse("DQA1*01:07Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:07Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:07Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_08():
    result = parse("DQA1*01:08")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_09():
    result = parse("DQA1*01:09")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_10():
    result = parse("DQA1*01:10")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_11():
    result = parse("DQA1*01:11")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_12():
    result = parse("DQA1*01:12")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_13():
    result = parse("DQA1*01:13")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_14():
    result = parse("DQA1*01:14")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_15N():
    result = parse("DQA1*01:15N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:15N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:15N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_16N():
    result = parse("DQA1*01:16N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:16N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:16N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_17():
    result = parse("DQA1*01:17")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_18():
    result = parse("DQA1*01:18")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_19():
    result = parse("DQA1*01:19")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_20():
    result = parse("DQA1*01:20")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_21():
    result = parse("DQA1*01:21")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_22():
    result = parse("DQA1*01:22")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_23():
    result = parse("DQA1*01:23")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_24():
    result = parse("DQA1*01:24")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_25():
    result = parse("DQA1*01:25")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_26():
    result = parse("DQA1*01:26")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_27():
    result = parse("DQA1*01:27")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_28():
    result = parse("DQA1*01:28")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_29():
    result = parse("DQA1*01:29")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_30():
    result = parse("DQA1*01:30")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_31():
    result = parse("DQA1*01:31")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_32():
    result = parse("DQA1*01:32")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_33():
    result = parse("DQA1*01:33")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_34():
    result = parse("DQA1*01:34")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_35():
    result = parse("DQA1*01:35")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_36():
    result = parse("DQA1*01:36")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_37():
    result = parse("DQA1*01:37")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_38_01_01():
    result = parse("DQA1*01:38:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:38:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:38:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_38_01_02():
    result = parse("DQA1*01:38:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:38:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*01:38:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_39():
    result = parse("DQA1*01:39")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_40Q():
    result = parse("DQA1*01:40Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*01:40Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:40Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_41():
    result = parse("DQA1*01:41")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_42():
    result = parse("DQA1*01:42")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_43():
    result = parse("DQA1*01:43")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_44():
    result = parse("DQA1*01:44")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_45():
    result = parse("DQA1*01:45")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_46():
    result = parse("DQA1*01:46")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_47():
    result = parse("DQA1*01:47")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_48():
    result = parse("DQA1*01:48")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_01_49():
    result = parse("DQA1*01:49")
    assert result.__class__ is Allele, f'Expected parse("DQA1*01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*01:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_02_01_01_01():
    result = parse("DQA1*02:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*02:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*02:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_02_01_01_02():
    result = parse("DQA1*02:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*02:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*02:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_02_01_02():
    result = parse("DQA1*02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*02:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_02_01_03():
    result = parse("DQA1*02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*02:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_02_02N():
    result = parse("DQA1*02:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*02:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*02:02N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_02_03():
    result = parse("DQA1*02:03")
    assert result.__class__ is Allele, f'Expected parse("DQA1*02:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*02:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_02_04():
    result = parse("DQA1*02:04")
    assert result.__class__ is Allele, f'Expected parse("DQA1*02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*02:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_02_05():
    result = parse("DQA1*02:05")
    assert result.__class__ is Allele, f'Expected parse("DQA1*02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*02:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_02_06():
    result = parse("DQA1*02:06")
    assert result.__class__ is Allele, f'Expected parse("DQA1*02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*02:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_02_07():
    result = parse("DQA1*02:07")
    assert result.__class__ is Allele, f'Expected parse("DQA1*02:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*02:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_02_08():
    result = parse("DQA1*02:08")
    assert result.__class__ is Allele, f'Expected parse("DQA1*02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*02:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_02_09():
    result = parse("DQA1*02:09")
    assert result.__class__ is Allele, f'Expected parse("DQA1*02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*02:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_02_10():
    result = parse("DQA1*02:10")
    assert result.__class__ is Allele, f'Expected parse("DQA1*02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*02:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_02_11():
    result = parse("DQA1*02:11")
    assert result.__class__ is Allele, f'Expected parse("DQA1*02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*02:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_02_12():
    result = parse("DQA1*02:12")
    assert result.__class__ is Allele, f'Expected parse("DQA1*02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*02:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_01_01_01():
    result = parse("DQA1*03:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*03:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_01_03():
    result = parse("DQA1*03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*03:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_01_04():
    result = parse("DQA1*03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*03:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_01_05():
    result = parse("DQA1*03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*03:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_01_06():
    result = parse("DQA1*03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*03:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_02_01_01():
    result = parse("DQA1*03:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*03:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_02_01_02():
    result = parse("DQA1*03:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*03:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_02_02():
    result = parse("DQA1*03:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*03:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_03_01_01():
    result = parse("DQA1*03:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*03:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_03_01_02():
    result = parse("DQA1*03:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*03:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_03_01_03():
    result = parse("DQA1*03:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*03:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_03_01_04():
    result = parse("DQA1*03:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*03:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_03_01_05():
    result = parse("DQA1*03:03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*03:03:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_03_01_06():
    result = parse("DQA1*03:03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*03:03:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_03_01_07():
    result = parse("DQA1*03:03:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:03:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*03:03:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_03_01_08():
    result = parse("DQA1*03:03:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:03:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*03:03:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_03_01_09():
    result = parse("DQA1*03:03:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:03:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*03:03:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_03_01_10():
    result = parse("DQA1*03:03:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:03:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*03:03:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_03_01_11():
    result = parse("DQA1*03:03:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:03:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*03:03:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_03_01_12():
    result = parse("DQA1*03:03:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:03:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*03:03:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_03_01_13():
    result = parse("DQA1*03:03:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:03:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*03:03:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_03_02():
    result = parse("DQA1*03:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*03:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_03_03():
    result = parse("DQA1*03:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*03:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*03:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_04():
    result = parse("DQA1*03:04")
    assert result.__class__ is Allele, f'Expected parse("DQA1*03:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*03:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_05():
    result = parse("DQA1*03:05")
    assert result.__class__ is Allele, f'Expected parse("DQA1*03:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*03:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_06():
    result = parse("DQA1*03:06")
    assert result.__class__ is Allele, f'Expected parse("DQA1*03:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*03:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_07():
    result = parse("DQA1*03:07")
    assert result.__class__ is Allele, f'Expected parse("DQA1*03:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*03:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_08():
    result = parse("DQA1*03:08")
    assert result.__class__ is Allele, f'Expected parse("DQA1*03:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*03:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_09():
    result = parse("DQA1*03:09")
    assert result.__class__ is Allele, f'Expected parse("DQA1*03:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*03:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_10():
    result = parse("DQA1*03:10")
    assert result.__class__ is Allele, f'Expected parse("DQA1*03:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*03:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_11():
    result = parse("DQA1*03:11")
    assert result.__class__ is Allele, f'Expected parse("DQA1*03:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*03:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_12():
    result = parse("DQA1*03:12")
    assert result.__class__ is Allele, f'Expected parse("DQA1*03:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*03:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_13():
    result = parse("DQA1*03:13")
    assert result.__class__ is Allele, f'Expected parse("DQA1*03:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*03:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_14():
    result = parse("DQA1*03:14")
    assert result.__class__ is Allele, f'Expected parse("DQA1*03:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*03:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_15():
    result = parse("DQA1*03:15")
    assert result.__class__ is Allele, f'Expected parse("DQA1*03:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*03:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_03_16():
    result = parse("DQA1*03:16")
    assert result.__class__ is Allele, f'Expected parse("DQA1*03:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*03:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_01_01_01():
    result = parse("DQA1*04:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*04:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*04:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_01_01_02():
    result = parse("DQA1*04:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*04:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*04:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_01_01_03():
    result = parse("DQA1*04:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*04:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*04:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_01_01_04():
    result = parse("DQA1*04:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*04:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*04:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_01_01_05():
    result = parse("DQA1*04:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*04:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*04:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_01_01_06():
    result = parse("DQA1*04:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*04:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*04:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_01_01_07():
    result = parse("DQA1*04:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*04:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*04:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_01_01_08():
    result = parse("DQA1*04:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*04:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*04:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_01_01_09():
    result = parse("DQA1*04:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*04:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*04:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_01_02_01():
    result = parse("DQA1*04:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*04:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*04:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_01_02_02():
    result = parse("DQA1*04:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*04:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*04:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_01_03():
    result = parse("DQA1*04:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*04:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*04:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_02():
    result = parse("DQA1*04:02")
    assert result.__class__ is Allele, f'Expected parse("DQA1*04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*04:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_03N():
    result = parse("DQA1*04:03N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*04:03N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*04:03N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_04():
    result = parse("DQA1*04:04")
    assert result.__class__ is Allele, f'Expected parse("DQA1*04:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*04:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_05():
    result = parse("DQA1*04:05")
    assert result.__class__ is Allele, f'Expected parse("DQA1*04:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*04:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_06():
    result = parse("DQA1*04:06")
    assert result.__class__ is Allele, f'Expected parse("DQA1*04:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*04:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_07():
    result = parse("DQA1*04:07")
    assert result.__class__ is Allele, f'Expected parse("DQA1*04:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*04:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_04_08():
    result = parse("DQA1*04:08")
    assert result.__class__ is Allele, f'Expected parse("DQA1*04:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*04:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_01_01_01():
    result = parse("DQA1*05:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_01_01_02():
    result = parse("DQA1*05:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_01_01_03():
    result = parse("DQA1*05:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_01_01_04():
    result = parse("DQA1*05:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_01_02():
    result = parse("DQA1*05:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*05:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_01_04():
    result = parse("DQA1*05:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*05:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_01_05():
    result = parse("DQA1*05:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*05:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_01_06():
    result = parse("DQA1*05:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*05:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_02():
    result = parse("DQA1*05:02")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_03_01_01():
    result = parse("DQA1*05:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_03_01_02():
    result = parse("DQA1*05:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_03_02():
    result = parse("DQA1*05:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*05:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_04():
    result = parse("DQA1*05:04")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_01():
    result = parse("DQA1*05:05:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_02():
    result = parse("DQA1*05:05:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_03():
    result = parse("DQA1*05:05:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_04():
    result = parse("DQA1*05:05:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_05():
    result = parse("DQA1*05:05:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_06():
    result = parse("DQA1*05:05:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_07():
    result = parse("DQA1*05:05:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_08():
    result = parse("DQA1*05:05:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_09():
    result = parse("DQA1*05:05:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_10():
    result = parse("DQA1*05:05:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_11():
    result = parse("DQA1*05:05:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_12():
    result = parse("DQA1*05:05:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_13():
    result = parse("DQA1*05:05:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_14():
    result = parse("DQA1*05:05:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_15():
    result = parse("DQA1*05:05:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_16():
    result = parse("DQA1*05:05:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_17():
    result = parse("DQA1*05:05:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_18():
    result = parse("DQA1*05:05:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_19():
    result = parse("DQA1*05:05:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_20():
    result = parse("DQA1*05:05:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_21():
    result = parse("DQA1*05:05:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_22():
    result = parse("DQA1*05:05:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_23():
    result = parse("DQA1*05:05:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_24():
    result = parse("DQA1*05:05:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_01_25():
    result = parse("DQA1*05:05:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:05:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_02():
    result = parse("DQA1*05:05:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*05:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_03():
    result = parse("DQA1*05:05:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*05:05:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_04():
    result = parse("DQA1*05:05:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*05:05:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_05_05():
    result = parse("DQA1*05:05:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:05:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*05:05:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_06_01_01():
    result = parse("DQA1*05:06:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:06:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:06:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_06_01_02():
    result = parse("DQA1*05:06:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:06:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*05:06:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_07():
    result = parse("DQA1*05:07")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_08():
    result = parse("DQA1*05:08")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_09():
    result = parse("DQA1*05:09")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_10():
    result = parse("DQA1*05:10")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_11():
    result = parse("DQA1*05:11")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_12():
    result = parse("DQA1*05:12")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_13():
    result = parse("DQA1*05:13")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_14():
    result = parse("DQA1*05:14")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_15N():
    result = parse("DQA1*05:15N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:15N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:15N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_16():
    result = parse("DQA1*05:16")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_17N():
    result = parse("DQA1*05:17N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*05:17N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:17N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_18():
    result = parse("DQA1*05:18")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_19():
    result = parse("DQA1*05:19")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_20():
    result = parse("DQA1*05:20")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_21():
    result = parse("DQA1*05:21")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_22():
    result = parse("DQA1*05:22")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_23():
    result = parse("DQA1*05:23")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_24():
    result = parse("DQA1*05:24")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_05_25():
    result = parse("DQA1*05:25")
    assert result.__class__ is Allele, f'Expected parse("DQA1*05:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*05:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_06_01_01_01():
    result = parse("DQA1*06:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*06:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*06:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_06_01_01_02():
    result = parse("DQA1*06:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*06:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*06:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_06_01_01_03():
    result = parse("DQA1*06:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*06:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*06:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_06_01_01_04():
    result = parse("DQA1*06:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*06:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA1*06:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_06_01_02():
    result = parse("DQA1*06:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA1*06:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA1*06:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA1_06_02():
    result = parse("DQA1*06:02")
    assert result.__class__ is Allele, f'Expected parse("DQA1*06:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA1*06:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_01_01():
    result = parse("DQA2*01:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_01_02():
    result = parse("DQA2*01:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_01_03():
    result = parse("DQA2*01:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_01_04():
    result = parse("DQA2*01:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_01_05():
    result = parse("DQA2*01:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_02_01():
    result = parse("DQA2*01:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_02_02():
    result = parse("DQA2*01:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_02_03():
    result = parse("DQA2*01:01:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_02_04():
    result = parse("DQA2*01:01:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_02_05():
    result = parse("DQA2*01:01:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_02_06():
    result = parse("DQA2*01:01:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:02:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_02_07():
    result = parse("DQA2*01:01:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:02:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_02_08():
    result = parse("DQA2*01:01:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:02:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_02_09():
    result = parse("DQA2*01:01:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:02:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_02_10():
    result = parse("DQA2*01:01:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:02:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_02_11():
    result = parse("DQA2*01:01:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:02:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_02_12():
    result = parse("DQA2*01:01:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:02:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_02_13():
    result = parse("DQA2*01:01:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:02:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_03():
    result = parse("DQA2*01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA2*01:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_04_01():
    result = parse("DQA2*01:01:04:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:04:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:04:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_04_02():
    result = parse("DQA2*01:01:04:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:04:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:04:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_04_03():
    result = parse("DQA2*01:01:04:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:04:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:01:04:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_01_05():
    result = parse("DQA2*01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA2*01:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_02():
    result = parse("DQA2*01:02")
    assert result.__class__ is Allele, f'Expected parse("DQA2*01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA2*01:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_03():
    result = parse("DQA2*01:03")
    assert result.__class__ is Allele, f'Expected parse("DQA2*01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA2*01:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_04_01_01():
    result = parse("DQA2*01:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_04_01_02():
    result = parse("DQA2*01:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_04_01_03():
    result = parse("DQA2*01:04:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:04:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:04:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_04_02():
    result = parse("DQA2*01:04:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:04:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQA2*01:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_05_01_01():
    result = parse("DQA2*01:05:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:05:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:05:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_05_01_02():
    result = parse("DQA2*01:05:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:05:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:05:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_05_01_03():
    result = parse("DQA2*01:05:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQA2*01:05:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQA2*01:05:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_06():
    result = parse("DQA2*01:06")
    assert result.__class__ is Allele, f'Expected parse("DQA2*01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA2*01:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_07():
    result = parse("DQA2*01:07")
    assert result.__class__ is Allele, f'Expected parse("DQA2*01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA2*01:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_08():
    result = parse("DQA2*01:08")
    assert result.__class__ is Allele, f'Expected parse("DQA2*01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA2*01:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_09():
    result = parse("DQA2*01:09")
    assert result.__class__ is Allele, f'Expected parse("DQA2*01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA2*01:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_10():
    result = parse("DQA2*01:10")
    assert result.__class__ is Allele, f'Expected parse("DQA2*01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA2*01:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQA2_01_11():
    result = parse("DQA2*01:11")
    assert result.__class__ is Allele, f'Expected parse("DQA2*01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQA2*01:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_01_01():
    result = parse("DQB1*02:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*02:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_01_02():
    result = parse("DQB1*02:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*02:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_02():
    result = parse("DQB1*02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_03():
    result = parse("DQB1*02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_04():
    result = parse("DQB1*02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_05():
    result = parse("DQB1*02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_06():
    result = parse("DQB1*02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_07():
    result = parse("DQB1*02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_08():
    result = parse("DQB1*02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_09():
    result = parse("DQB1*02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_10():
    result = parse("DQB1*02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_11():
    result = parse("DQB1*02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_12():
    result = parse("DQB1*02:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_13():
    result = parse("DQB1*02:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_14():
    result = parse("DQB1*02:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_15():
    result = parse("DQB1*02:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_16():
    result = parse("DQB1*02:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_17():
    result = parse("DQB1*02:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_18():
    result = parse("DQB1*02:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_19():
    result = parse("DQB1*02:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_20():
    result = parse("DQB1*02:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_21():
    result = parse("DQB1*02:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_22():
    result = parse("DQB1*02:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_23():
    result = parse("DQB1*02:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_24():
    result = parse("DQB1*02:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_25():
    result = parse("DQB1*02:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_26():
    result = parse("DQB1*02:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_27():
    result = parse("DQB1*02:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_28():
    result = parse("DQB1*02:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_29():
    result = parse("DQB1*02:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_30():
    result = parse("DQB1*02:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_31():
    result = parse("DQB1*02:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_32():
    result = parse("DQB1*02:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_33():
    result = parse("DQB1*02:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_34():
    result = parse("DQB1*02:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_35():
    result = parse("DQB1*02:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_36():
    result = parse("DQB1*02:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_37():
    result = parse("DQB1*02:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_01_38():
    result = parse("DQB1*02:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_01_01():
    result = parse("DQB1*02:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*02:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_01_02():
    result = parse("DQB1*02:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*02:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_01_03():
    result = parse("DQB1*02:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*02:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_01_04():
    result = parse("DQB1*02:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*02:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_01_05():
    result = parse("DQB1*02:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*02:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_02():
    result = parse("DQB1*02:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_03():
    result = parse("DQB1*02:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_04():
    result = parse("DQB1*02:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_05():
    result = parse("DQB1*02:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_06_02():
    result = parse("DQB1*02:02:06:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:06:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*02:02:06:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_07():
    result = parse("DQB1*02:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_08():
    result = parse("DQB1*02:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_09():
    result = parse("DQB1*02:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_10():
    result = parse("DQB1*02:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_11():
    result = parse("DQB1*02:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_12():
    result = parse("DQB1*02:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_02_13():
    result = parse("DQB1*02:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_03_01():
    result = parse("DQB1*02:03:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:03:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:03:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_03_02():
    result = parse("DQB1*02:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_04():
    result = parse("DQB1*02:04")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_05():
    result = parse("DQB1*02:05")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_06():
    result = parse("DQB1*02:06")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_07_01():
    result = parse("DQB1*02:07:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:07:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_07_02():
    result = parse("DQB1*02:07:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:07:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_08():
    result = parse("DQB1*02:08")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_09():
    result = parse("DQB1*02:09")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_10():
    result = parse("DQB1*02:10")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_100():
    result = parse("DQB1*02:100")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_101():
    result = parse("DQB1*02:101")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_102():
    result = parse("DQB1*02:102")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_103():
    result = parse("DQB1*02:103")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_104():
    result = parse("DQB1*02:104")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_105():
    result = parse("DQB1*02:105")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_106():
    result = parse("DQB1*02:106")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_107():
    result = parse("DQB1*02:107")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_108():
    result = parse("DQB1*02:108")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_109():
    result = parse("DQB1*02:109")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_11():
    result = parse("DQB1*02:11")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_110():
    result = parse("DQB1*02:110")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_111():
    result = parse("DQB1*02:111")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_112():
    result = parse("DQB1*02:112")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_113():
    result = parse("DQB1*02:113")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_114():
    result = parse("DQB1*02:114")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_115():
    result = parse("DQB1*02:115")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:115") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_116():
    result = parse("DQB1*02:116")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_117():
    result = parse("DQB1*02:117")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_118():
    result = parse("DQB1*02:118")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:118") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_119():
    result = parse("DQB1*02:119")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:119") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_12():
    result = parse("DQB1*02:12")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_120():
    result = parse("DQB1*02:120")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:120") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_121():
    result = parse("DQB1*02:121")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:121") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_122():
    result = parse("DQB1*02:122")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:122") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_123():
    result = parse("DQB1*02:123")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:123") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_124():
    result = parse("DQB1*02:124")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:124") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_125():
    result = parse("DQB1*02:125")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:125") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_126():
    result = parse("DQB1*02:126")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:126") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_127():
    result = parse("DQB1*02:127")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:127") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_128():
    result = parse("DQB1*02:128")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:128") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_129N():
    result = parse("DQB1*02:129N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:129N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:129N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_13():
    result = parse("DQB1*02:13")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_130():
    result = parse("DQB1*02:130")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:130") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_131():
    result = parse("DQB1*02:131")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:131") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_132N():
    result = parse("DQB1*02:132N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:132N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:132N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_133():
    result = parse("DQB1*02:133")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:133") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_134N():
    result = parse("DQB1*02:134N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:134N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:134N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_135():
    result = parse("DQB1*02:135")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:135") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_136():
    result = parse("DQB1*02:136")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:136") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_137():
    result = parse("DQB1*02:137")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:137") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_138():
    result = parse("DQB1*02:138")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:138") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_139():
    result = parse("DQB1*02:139")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:139") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_140():
    result = parse("DQB1*02:140")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:140") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_141():
    result = parse("DQB1*02:141")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:141") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_142():
    result = parse("DQB1*02:142")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:142") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_143():
    result = parse("DQB1*02:143")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:143") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_144():
    result = parse("DQB1*02:144")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:144") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_145():
    result = parse("DQB1*02:145")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:145") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_146():
    result = parse("DQB1*02:146")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:146") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_147():
    result = parse("DQB1*02:147")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:147") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_148():
    result = parse("DQB1*02:148")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:148") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_149():
    result = parse("DQB1*02:149")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:149") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_14_01():
    result = parse("DQB1*02:14:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:14:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:14:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_14_02():
    result = parse("DQB1*02:14:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:14:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:14:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_15():
    result = parse("DQB1*02:15")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_150():
    result = parse("DQB1*02:150")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:150") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_151():
    result = parse("DQB1*02:151")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:151") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_152():
    result = parse("DQB1*02:152")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:152") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_153():
    result = parse("DQB1*02:153")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:153") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_154():
    result = parse("DQB1*02:154")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:154") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_155():
    result = parse("DQB1*02:155")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:155") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_156():
    result = parse("DQB1*02:156")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:156") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_157():
    result = parse("DQB1*02:157")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:157") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_158():
    result = parse("DQB1*02:158")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:158") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_159():
    result = parse("DQB1*02:159")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:159") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_16():
    result = parse("DQB1*02:16")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_160():
    result = parse("DQB1*02:160")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:160") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_161():
    result = parse("DQB1*02:161")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:161") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_162N():
    result = parse("DQB1*02:162N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:162N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:162N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_163N():
    result = parse("DQB1*02:163N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:163N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:163N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_164():
    result = parse("DQB1*02:164")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:164") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_165():
    result = parse("DQB1*02:165")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:165") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_166():
    result = parse("DQB1*02:166")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:166") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_167N():
    result = parse("DQB1*02:167N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:167N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:167N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_168():
    result = parse("DQB1*02:168")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:168") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_169():
    result = parse("DQB1*02:169")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:169") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_17():
    result = parse("DQB1*02:17")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_170():
    result = parse("DQB1*02:170")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:170") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_171Q():
    result = parse("DQB1*02:171Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:171Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:171Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_172():
    result = parse("DQB1*02:172")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:172") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_173():
    result = parse("DQB1*02:173")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:173") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_174():
    result = parse("DQB1*02:174")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:174") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_18N():
    result = parse("DQB1*02:18N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:18N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:18N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_19():
    result = parse("DQB1*02:19")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_20N():
    result = parse("DQB1*02:20N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:20N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:20N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_21():
    result = parse("DQB1*02:21")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_22():
    result = parse("DQB1*02:22")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_23():
    result = parse("DQB1*02:23")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_24():
    result = parse("DQB1*02:24")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_25():
    result = parse("DQB1*02:25")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_26():
    result = parse("DQB1*02:26")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_27():
    result = parse("DQB1*02:27")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_28():
    result = parse("DQB1*02:28")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_29():
    result = parse("DQB1*02:29")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_30():
    result = parse("DQB1*02:30")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_31():
    result = parse("DQB1*02:31")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_32():
    result = parse("DQB1*02:32")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_33():
    result = parse("DQB1*02:33")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_34():
    result = parse("DQB1*02:34")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_35():
    result = parse("DQB1*02:35")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_36():
    result = parse("DQB1*02:36")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_37():
    result = parse("DQB1*02:37")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_38():
    result = parse("DQB1*02:38")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_39():
    result = parse("DQB1*02:39")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_40():
    result = parse("DQB1*02:40")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_41():
    result = parse("DQB1*02:41")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_42():
    result = parse("DQB1*02:42")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_43():
    result = parse("DQB1*02:43")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_44():
    result = parse("DQB1*02:44")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_45():
    result = parse("DQB1*02:45")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_46():
    result = parse("DQB1*02:46")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_47():
    result = parse("DQB1*02:47")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_48():
    result = parse("DQB1*02:48")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_49():
    result = parse("DQB1*02:49")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_50():
    result = parse("DQB1*02:50")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_51():
    result = parse("DQB1*02:51")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_52():
    result = parse("DQB1*02:52")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_53Q():
    result = parse("DQB1*02:53Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:53Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:53Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_54():
    result = parse("DQB1*02:54")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_55():
    result = parse("DQB1*02:55")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_56():
    result = parse("DQB1*02:56")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_57():
    result = parse("DQB1*02:57")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_58N():
    result = parse("DQB1*02:58N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:58N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:58N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_59():
    result = parse("DQB1*02:59")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_60():
    result = parse("DQB1*02:60")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_61():
    result = parse("DQB1*02:61")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_62():
    result = parse("DQB1*02:62")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_63():
    result = parse("DQB1*02:63")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_64():
    result = parse("DQB1*02:64")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_65():
    result = parse("DQB1*02:65")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_66():
    result = parse("DQB1*02:66")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_67N():
    result = parse("DQB1*02:67N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:67N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:67N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_68():
    result = parse("DQB1*02:68")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_69():
    result = parse("DQB1*02:69")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_70():
    result = parse("DQB1*02:70")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_71():
    result = parse("DQB1*02:71")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_72():
    result = parse("DQB1*02:72")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_73():
    result = parse("DQB1*02:73")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_74():
    result = parse("DQB1*02:74")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_75():
    result = parse("DQB1*02:75")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_76():
    result = parse("DQB1*02:76")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_77():
    result = parse("DQB1*02:77")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_78():
    result = parse("DQB1*02:78")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_79():
    result = parse("DQB1*02:79")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_80():
    result = parse("DQB1*02:80")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_81():
    result = parse("DQB1*02:81")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_82():
    result = parse("DQB1*02:82")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_83():
    result = parse("DQB1*02:83")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_84():
    result = parse("DQB1*02:84")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_85():
    result = parse("DQB1*02:85")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_86():
    result = parse("DQB1*02:86")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_87():
    result = parse("DQB1*02:87")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_88():
    result = parse("DQB1*02:88")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_89_01():
    result = parse("DQB1*02:89:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:89:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:89:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_89_02():
    result = parse("DQB1*02:89:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:89:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*02:89:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_90():
    result = parse("DQB1*02:90")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_91():
    result = parse("DQB1*02:91")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_92():
    result = parse("DQB1*02:92")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_93():
    result = parse("DQB1*02:93")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_94():
    result = parse("DQB1*02:94")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_95():
    result = parse("DQB1*02:95")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_96N():
    result = parse("DQB1*02:96N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*02:96N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:96N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_97():
    result = parse("DQB1*02:97")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_98():
    result = parse("DQB1*02:98")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_02_99():
    result = parse("DQB1*02:99")
    assert result.__class__ is Allele, f'Expected parse("DQB1*02:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*02:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_01():
    result = parse("DQB1*03:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_02():
    result = parse("DQB1*03:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_03():
    result = parse("DQB1*03:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_04():
    result = parse("DQB1*03:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_05():
    result = parse("DQB1*03:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_06():
    result = parse("DQB1*03:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_07():
    result = parse("DQB1*03:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_08():
    result = parse("DQB1*03:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_09():
    result = parse("DQB1*03:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_10():
    result = parse("DQB1*03:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_11():
    result = parse("DQB1*03:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_12():
    result = parse("DQB1*03:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_14():
    result = parse("DQB1*03:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_15():
    result = parse("DQB1*03:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_16():
    result = parse("DQB1*03:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_17():
    result = parse("DQB1*03:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_18():
    result = parse("DQB1*03:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_19():
    result = parse("DQB1*03:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_20():
    result = parse("DQB1*03:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_21Q():
    result = parse("DQB1*03:01:01:21Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:21Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:21Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_22():
    result = parse("DQB1*03:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_23():
    result = parse("DQB1*03:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_01_24():
    result = parse("DQB1*03:01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:01:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_02():
    result = parse("DQB1*03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_03():
    result = parse("DQB1*03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_04():
    result = parse("DQB1*03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_05():
    result = parse("DQB1*03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_06():
    result = parse("DQB1*03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_07():
    result = parse("DQB1*03:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_08():
    result = parse("DQB1*03:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_09():
    result = parse("DQB1*03:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_10():
    result = parse("DQB1*03:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_11():
    result = parse("DQB1*03:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_12():
    result = parse("DQB1*03:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_13():
    result = parse("DQB1*03:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_14():
    result = parse("DQB1*03:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_15():
    result = parse("DQB1*03:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_16():
    result = parse("DQB1*03:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_17():
    result = parse("DQB1*03:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_18():
    result = parse("DQB1*03:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_19():
    result = parse("DQB1*03:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_20():
    result = parse("DQB1*03:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_21():
    result = parse("DQB1*03:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_22():
    result = parse("DQB1*03:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_23():
    result = parse("DQB1*03:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_24():
    result = parse("DQB1*03:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_25():
    result = parse("DQB1*03:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_26():
    result = parse("DQB1*03:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_27():
    result = parse("DQB1*03:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_28():
    result = parse("DQB1*03:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_29():
    result = parse("DQB1*03:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_30():
    result = parse("DQB1*03:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_31():
    result = parse("DQB1*03:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_32():
    result = parse("DQB1*03:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_33():
    result = parse("DQB1*03:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_34():
    result = parse("DQB1*03:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_35():
    result = parse("DQB1*03:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_36():
    result = parse("DQB1*03:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_37():
    result = parse("DQB1*03:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_38():
    result = parse("DQB1*03:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_39():
    result = parse("DQB1*03:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_40():
    result = parse("DQB1*03:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_41():
    result = parse("DQB1*03:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_42():
    result = parse("DQB1*03:01:42")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_43():
    result = parse("DQB1*03:01:43")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_44():
    result = parse("DQB1*03:01:44")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_45():
    result = parse("DQB1*03:01:45")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:45") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:45") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_46():
    result = parse("DQB1*03:01:46")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:46") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:46") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_47():
    result = parse("DQB1*03:01:47")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:47") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:47") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_48():
    result = parse("DQB1*03:01:48")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:48") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:48") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_01_49():
    result = parse("DQB1*03:01:49")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:01:49") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:01:49") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_01_01():
    result = parse("DQB1*03:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_01_02():
    result = parse("DQB1*03:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_01_03():
    result = parse("DQB1*03:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_01_04():
    result = parse("DQB1*03:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_01_05():
    result = parse("DQB1*03:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_01_06():
    result = parse("DQB1*03:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_01_07():
    result = parse("DQB1*03:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_01_08():
    result = parse("DQB1*03:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_02():
    result = parse("DQB1*03:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_03():
    result = parse("DQB1*03:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_04():
    result = parse("DQB1*03:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_05():
    result = parse("DQB1*03:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_06():
    result = parse("DQB1*03:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_07():
    result = parse("DQB1*03:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_08():
    result = parse("DQB1*03:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_09():
    result = parse("DQB1*03:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_10():
    result = parse("DQB1*03:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_11():
    result = parse("DQB1*03:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_12():
    result = parse("DQB1*03:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_13():
    result = parse("DQB1*03:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_14():
    result = parse("DQB1*03:02:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_15():
    result = parse("DQB1*03:02:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_16():
    result = parse("DQB1*03:02:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_17():
    result = parse("DQB1*03:02:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_18():
    result = parse("DQB1*03:02:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_19():
    result = parse("DQB1*03:02:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_20():
    result = parse("DQB1*03:02:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_21():
    result = parse("DQB1*03:02:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_22():
    result = parse("DQB1*03:02:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_23():
    result = parse("DQB1*03:02:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_24():
    result = parse("DQB1*03:02:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_25():
    result = parse("DQB1*03:02:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_26():
    result = parse("DQB1*03:02:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_27():
    result = parse("DQB1*03:02:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_28():
    result = parse("DQB1*03:02:28")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_29():
    result = parse("DQB1*03:02:29")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_30():
    result = parse("DQB1*03:02:30")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_31():
    result = parse("DQB1*03:02:31")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_32():
    result = parse("DQB1*03:02:32")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_02_33():
    result = parse("DQB1*03:02:33")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:02:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:02:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_02_01():
    result = parse("DQB1*03:03:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:03:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_02_02():
    result = parse("DQB1*03:03:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:03:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_02_03():
    result = parse("DQB1*03:03:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:03:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_02_04():
    result = parse("DQB1*03:03:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:03:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_02_05():
    result = parse("DQB1*03:03:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:03:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_03():
    result = parse("DQB1*03:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_04():
    result = parse("DQB1*03:03:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_05():
    result = parse("DQB1*03:03:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_06():
    result = parse("DQB1*03:03:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_07():
    result = parse("DQB1*03:03:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_08():
    result = parse("DQB1*03:03:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_09():
    result = parse("DQB1*03:03:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_10():
    result = parse("DQB1*03:03:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_11():
    result = parse("DQB1*03:03:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_12():
    result = parse("DQB1*03:03:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_13():
    result = parse("DQB1*03:03:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_14():
    result = parse("DQB1*03:03:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_15():
    result = parse("DQB1*03:03:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_16():
    result = parse("DQB1*03:03:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_17():
    result = parse("DQB1*03:03:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_18():
    result = parse("DQB1*03:03:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_19():
    result = parse("DQB1*03:03:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_20():
    result = parse("DQB1*03:03:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_21():
    result = parse("DQB1*03:03:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_22():
    result = parse("DQB1*03:03:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_23():
    result = parse("DQB1*03:03:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_24():
    result = parse("DQB1*03:03:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_25():
    result = parse("DQB1*03:03:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_26():
    result = parse("DQB1*03:03:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_03_27():
    result = parse("DQB1*03:03:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:03:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:03:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_04_01_01():
    result = parse("DQB1*03:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_04_01_02():
    result = parse("DQB1*03:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_04_02():
    result = parse("DQB1*03:04:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:04:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_04_03():
    result = parse("DQB1*03:04:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:04:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_04_04():
    result = parse("DQB1*03:04:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:04:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:04:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_05_01():
    result = parse("DQB1*03:05:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:05:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_05_02():
    result = parse("DQB1*03:05:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:05:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_05_03():
    result = parse("DQB1*03:05:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:05:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:05:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_05_04():
    result = parse("DQB1*03:05:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:05:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:05:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_05_05():
    result = parse("DQB1*03:05:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:05:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:05:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_06():
    result = parse("DQB1*03:06")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_07():
    result = parse("DQB1*03:07")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_08():
    result = parse("DQB1*03:08")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_09():
    result = parse("DQB1*03:09")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_100():
    result = parse("DQB1*03:100")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_101():
    result = parse("DQB1*03:101")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_102():
    result = parse("DQB1*03:102")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_103():
    result = parse("DQB1*03:103")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_104():
    result = parse("DQB1*03:104")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_105():
    result = parse("DQB1*03:105")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_106():
    result = parse("DQB1*03:106")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_107():
    result = parse("DQB1*03:107")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_108():
    result = parse("DQB1*03:108")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_109():
    result = parse("DQB1*03:109")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_10_01():
    result = parse("DQB1*03:10:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:10:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:10:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_10_02_01():
    result = parse("DQB1*03:10:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:10:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:10:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_10_02_02():
    result = parse("DQB1*03:10:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:10:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:10:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_10_03():
    result = parse("DQB1*03:10:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:10:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:10:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_11():
    result = parse("DQB1*03:11")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_110():
    result = parse("DQB1*03:110")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_111():
    result = parse("DQB1*03:111")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_112():
    result = parse("DQB1*03:112")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_113():
    result = parse("DQB1*03:113")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_114():
    result = parse("DQB1*03:114")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_115():
    result = parse("DQB1*03:115")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:115") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_116():
    result = parse("DQB1*03:116")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_117():
    result = parse("DQB1*03:117")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_118N():
    result = parse("DQB1*03:118N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:118N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:118N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_119():
    result = parse("DQB1*03:119")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:119") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_12():
    result = parse("DQB1*03:12")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_120():
    result = parse("DQB1*03:120")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:120") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_121():
    result = parse("DQB1*03:121")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:121") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_122():
    result = parse("DQB1*03:122")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:122") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_123():
    result = parse("DQB1*03:123")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:123") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_124():
    result = parse("DQB1*03:124")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:124") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_125():
    result = parse("DQB1*03:125")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:125") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_126():
    result = parse("DQB1*03:126")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:126") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_127():
    result = parse("DQB1*03:127")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:127") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_128():
    result = parse("DQB1*03:128")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:128") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_129():
    result = parse("DQB1*03:129")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:129") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_13():
    result = parse("DQB1*03:13")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_130():
    result = parse("DQB1*03:130")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:130") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_131():
    result = parse("DQB1*03:131")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:131") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_132():
    result = parse("DQB1*03:132")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:132") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_133():
    result = parse("DQB1*03:133")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:133") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_134():
    result = parse("DQB1*03:134")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:134") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_135():
    result = parse("DQB1*03:135")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:135") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_136():
    result = parse("DQB1*03:136")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:136") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_137():
    result = parse("DQB1*03:137")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:137") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_138():
    result = parse("DQB1*03:138")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:138") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_139():
    result = parse("DQB1*03:139")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:139") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_140():
    result = parse("DQB1*03:140")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:140") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_141():
    result = parse("DQB1*03:141")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:141") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_142():
    result = parse("DQB1*03:142")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:142") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_143():
    result = parse("DQB1*03:143")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:143") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_144():
    result = parse("DQB1*03:144")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:144") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_145():
    result = parse("DQB1*03:145")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:145") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_146():
    result = parse("DQB1*03:146")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:146") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_147():
    result = parse("DQB1*03:147")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:147") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_148():
    result = parse("DQB1*03:148")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:148") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_149():
    result = parse("DQB1*03:149")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:149") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_14_01():
    result = parse("DQB1*03:14:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:14:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:14:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_14_02():
    result = parse("DQB1*03:14:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:14:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:14:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_15():
    result = parse("DQB1*03:15")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_150():
    result = parse("DQB1*03:150")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:150") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_151():
    result = parse("DQB1*03:151")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:151") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_152():
    result = parse("DQB1*03:152")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:152") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_153():
    result = parse("DQB1*03:153")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:153") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_154():
    result = parse("DQB1*03:154")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:154") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_155():
    result = parse("DQB1*03:155")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:155") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_156():
    result = parse("DQB1*03:156")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:156") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_157():
    result = parse("DQB1*03:157")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:157") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_158():
    result = parse("DQB1*03:158")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:158") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_159():
    result = parse("DQB1*03:159")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:159") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_16():
    result = parse("DQB1*03:16")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_160():
    result = parse("DQB1*03:160")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:160") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_161():
    result = parse("DQB1*03:161")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:161") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_162():
    result = parse("DQB1*03:162")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:162") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_163():
    result = parse("DQB1*03:163")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:163") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_164():
    result = parse("DQB1*03:164")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:164") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_165():
    result = parse("DQB1*03:165")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:165") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_166():
    result = parse("DQB1*03:166")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:166") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_167():
    result = parse("DQB1*03:167")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:167") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_168():
    result = parse("DQB1*03:168")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:168") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_169():
    result = parse("DQB1*03:169")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:169") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_170():
    result = parse("DQB1*03:170")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:170") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_171():
    result = parse("DQB1*03:171")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:171") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_172():
    result = parse("DQB1*03:172")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:172") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_173():
    result = parse("DQB1*03:173")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:173") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_174():
    result = parse("DQB1*03:174")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:174") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_175():
    result = parse("DQB1*03:175")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:175") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_176():
    result = parse("DQB1*03:176")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:176") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_177():
    result = parse("DQB1*03:177")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:177") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_178():
    result = parse("DQB1*03:178")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:178") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_179():
    result = parse("DQB1*03:179")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:179") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_17_01():
    result = parse("DQB1*03:17:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:17:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:17:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_17_02():
    result = parse("DQB1*03:17:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:17:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:17:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_18():
    result = parse("DQB1*03:18")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_180():
    result = parse("DQB1*03:180")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:180") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_181():
    result = parse("DQB1*03:181")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:181") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_182():
    result = parse("DQB1*03:182")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:182") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_183():
    result = parse("DQB1*03:183")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:183") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_184():
    result = parse("DQB1*03:184")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:184") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_185():
    result = parse("DQB1*03:185")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:185") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_186():
    result = parse("DQB1*03:186")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:186") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_187():
    result = parse("DQB1*03:187")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:187") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_188():
    result = parse("DQB1*03:188")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:188") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_189():
    result = parse("DQB1*03:189")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:189") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_190():
    result = parse("DQB1*03:190")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:190") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_191():
    result = parse("DQB1*03:191")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:191") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_192():
    result = parse("DQB1*03:192")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:192") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_193():
    result = parse("DQB1*03:193")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:193") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_194():
    result = parse("DQB1*03:194")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:194") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_195():
    result = parse("DQB1*03:195")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:195") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_196():
    result = parse("DQB1*03:196")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:196") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_197Q():
    result = parse("DQB1*03:197Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:197Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:197Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_198_01():
    result = parse("DQB1*03:198:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:198:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:198:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_198_02():
    result = parse("DQB1*03:198:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:198:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:198:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_199():
    result = parse("DQB1*03:199")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:199") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_19_01_01():
    result = parse("DQB1*03:19:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:19:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:19:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_19_01_02Q():
    result = parse("DQB1*03:19:01:02Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:19:01:02Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*03:19:01:02Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_19_02():
    result = parse("DQB1*03:19:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:19:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:19:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_19_03():
    result = parse("DQB1*03:19:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:19:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:19:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_19_04():
    result = parse("DQB1*03:19:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:19:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:19:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_20():
    result = parse("DQB1*03:20")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_200():
    result = parse("DQB1*03:200")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:200") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_201():
    result = parse("DQB1*03:201")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:201") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_202():
    result = parse("DQB1*03:202")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:202") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_203():
    result = parse("DQB1*03:203")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:203") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_204():
    result = parse("DQB1*03:204")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:204") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_205():
    result = parse("DQB1*03:205")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:205") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_206():
    result = parse("DQB1*03:206")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:206") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:206") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_207():
    result = parse("DQB1*03:207")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:207") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_208():
    result = parse("DQB1*03:208")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:208") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_209():
    result = parse("DQB1*03:209")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:209") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_21():
    result = parse("DQB1*03:21")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_210():
    result = parse("DQB1*03:210")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:210") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_211():
    result = parse("DQB1*03:211")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:211") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_212():
    result = parse("DQB1*03:212")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:212") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_213N():
    result = parse("DQB1*03:213N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:213N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:213N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_214():
    result = parse("DQB1*03:214")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:214") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_215():
    result = parse("DQB1*03:215")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:215") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_216():
    result = parse("DQB1*03:216")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:216") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_217():
    result = parse("DQB1*03:217")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:217") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_218():
    result = parse("DQB1*03:218")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:218") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_219():
    result = parse("DQB1*03:219")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:219") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_220():
    result = parse("DQB1*03:220")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:220") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_221():
    result = parse("DQB1*03:221")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:221") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_222():
    result = parse("DQB1*03:222")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:222") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_223():
    result = parse("DQB1*03:223")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:223") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_224():
    result = parse("DQB1*03:224")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:224") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_225():
    result = parse("DQB1*03:225")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:225") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_226():
    result = parse("DQB1*03:226")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:226") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_227():
    result = parse("DQB1*03:227")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:227") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_228():
    result = parse("DQB1*03:228")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:228") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_229():
    result = parse("DQB1*03:229")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:229") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_22_01():
    result = parse("DQB1*03:22:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:22:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:22:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_22_02():
    result = parse("DQB1*03:22:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:22:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:22:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_230():
    result = parse("DQB1*03:230")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:230") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_231():
    result = parse("DQB1*03:231")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:231") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_232():
    result = parse("DQB1*03:232")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:232") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_233():
    result = parse("DQB1*03:233")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:233") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_234():
    result = parse("DQB1*03:234")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:234") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_235():
    result = parse("DQB1*03:235")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:235") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_236():
    result = parse("DQB1*03:236")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:236") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_237N():
    result = parse("DQB1*03:237N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:237N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:237N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_238():
    result = parse("DQB1*03:238")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:238") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_239():
    result = parse("DQB1*03:239")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:239") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_23_01():
    result = parse("DQB1*03:23:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:23:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:23:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_23_02():
    result = parse("DQB1*03:23:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:23:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:23:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_23_03():
    result = parse("DQB1*03:23:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:23:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:23:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_24():
    result = parse("DQB1*03:24")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_240():
    result = parse("DQB1*03:240")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:240") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_241():
    result = parse("DQB1*03:241")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:241") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_242():
    result = parse("DQB1*03:242")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:242") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_243():
    result = parse("DQB1*03:243")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:243") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_244():
    result = parse("DQB1*03:244")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:244") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_245():
    result = parse("DQB1*03:245")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:245") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_246():
    result = parse("DQB1*03:246")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:246") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_247():
    result = parse("DQB1*03:247")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:247") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_248():
    result = parse("DQB1*03:248")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:248") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_249():
    result = parse("DQB1*03:249")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:249") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_250():
    result = parse("DQB1*03:250")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:250") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_251():
    result = parse("DQB1*03:251")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:251") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_252():
    result = parse("DQB1*03:252")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:252") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_253():
    result = parse("DQB1*03:253")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:253") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_254():
    result = parse("DQB1*03:254")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:254") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_255():
    result = parse("DQB1*03:255")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:255") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_256():
    result = parse("DQB1*03:256")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:256") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_257():
    result = parse("DQB1*03:257")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:257") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_258():
    result = parse("DQB1*03:258")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:258") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_259():
    result = parse("DQB1*03:259")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:259") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_25_01():
    result = parse("DQB1*03:25:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:25:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:25:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_25_02():
    result = parse("DQB1*03:25:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:25:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:25:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_26():
    result = parse("DQB1*03:26")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_260():
    result = parse("DQB1*03:260")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:260") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_261():
    result = parse("DQB1*03:261")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:261") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_262():
    result = parse("DQB1*03:262")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:262") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_263():
    result = parse("DQB1*03:263")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:263") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_264():
    result = parse("DQB1*03:264")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:264") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_265():
    result = parse("DQB1*03:265")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:265") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_266():
    result = parse("DQB1*03:266")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:266") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_267():
    result = parse("DQB1*03:267")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:267") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_268():
    result = parse("DQB1*03:268")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:268") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_269N():
    result = parse("DQB1*03:269N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:269N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:269N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_27():
    result = parse("DQB1*03:27")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_270():
    result = parse("DQB1*03:270")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:270") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:270") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_271():
    result = parse("DQB1*03:271")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:271") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_272():
    result = parse("DQB1*03:272")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:272") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_273():
    result = parse("DQB1*03:273")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:273") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_274():
    result = parse("DQB1*03:274")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:274") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_275():
    result = parse("DQB1*03:275")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:275") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_277():
    result = parse("DQB1*03:277")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:277") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_278():
    result = parse("DQB1*03:278")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:278") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_279():
    result = parse("DQB1*03:279")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:279") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_28():
    result = parse("DQB1*03:28")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_280():
    result = parse("DQB1*03:280")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:280") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_281():
    result = parse("DQB1*03:281")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:281") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_282N():
    result = parse("DQB1*03:282N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:282N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:282N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_283():
    result = parse("DQB1*03:283")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:283") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_284():
    result = parse("DQB1*03:284")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:284") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_285():
    result = parse("DQB1*03:285")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:285") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_286():
    result = parse("DQB1*03:286")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:286") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_287():
    result = parse("DQB1*03:287")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:287") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:287") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_288():
    result = parse("DQB1*03:288")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:288") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_289():
    result = parse("DQB1*03:289")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:289") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_29():
    result = parse("DQB1*03:29")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_290():
    result = parse("DQB1*03:290")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:290") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_291():
    result = parse("DQB1*03:291")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:291") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_292():
    result = parse("DQB1*03:292")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:292") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_293():
    result = parse("DQB1*03:293")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:293") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_294():
    result = parse("DQB1*03:294")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:294") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_295():
    result = parse("DQB1*03:295")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:295") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_296():
    result = parse("DQB1*03:296")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:296") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_297():
    result = parse("DQB1*03:297")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:297") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_298():
    result = parse("DQB1*03:298")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:298") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_299():
    result = parse("DQB1*03:299")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:299") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_30():
    result = parse("DQB1*03:30")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_300():
    result = parse("DQB1*03:300")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:300") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_301():
    result = parse("DQB1*03:301")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:301") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_302():
    result = parse("DQB1*03:302")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:302") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_303N():
    result = parse("DQB1*03:303N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:303N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:303N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_304():
    result = parse("DQB1*03:304")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:304") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:304") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_305():
    result = parse("DQB1*03:305")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:305") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_306():
    result = parse("DQB1*03:306")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:306") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:306") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_307():
    result = parse("DQB1*03:307")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:307") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_308():
    result = parse("DQB1*03:308")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:308") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:308") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_309():
    result = parse("DQB1*03:309")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:309") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:309") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_31():
    result = parse("DQB1*03:31")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_310N():
    result = parse("DQB1*03:310N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:310N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:310N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_311():
    result = parse("DQB1*03:311")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:311") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:311") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_312():
    result = parse("DQB1*03:312")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:312") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:312") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_313():
    result = parse("DQB1*03:313")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:313") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:313") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_314():
    result = parse("DQB1*03:314")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:314") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:314") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_315():
    result = parse("DQB1*03:315")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:315") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:315") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_316():
    result = parse("DQB1*03:316")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:316") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:316") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_317_01():
    result = parse("DQB1*03:317:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:317:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:317:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_317_02():
    result = parse("DQB1*03:317:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:317:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:317:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_318():
    result = parse("DQB1*03:318")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:318") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:318") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_319():
    result = parse("DQB1*03:319")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:319") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_32():
    result = parse("DQB1*03:32")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_320():
    result = parse("DQB1*03:320")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:320") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:320") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_321():
    result = parse("DQB1*03:321")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:321") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:321") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_322():
    result = parse("DQB1*03:322")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:322") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:322") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_323():
    result = parse("DQB1*03:323")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:323") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:323") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_324():
    result = parse("DQB1*03:324")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:324") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:324") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_326():
    result = parse("DQB1*03:326")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:326") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:326") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_327():
    result = parse("DQB1*03:327")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:327") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:327") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_328():
    result = parse("DQB1*03:328")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:328") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:328") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_329():
    result = parse("DQB1*03:329")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:329") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:329") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_33():
    result = parse("DQB1*03:33")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_330():
    result = parse("DQB1*03:330")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:330") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:330") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_331():
    result = parse("DQB1*03:331")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:331") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:331") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_332():
    result = parse("DQB1*03:332")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:332") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:332") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_333():
    result = parse("DQB1*03:333")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:333") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:333") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_334N():
    result = parse("DQB1*03:334N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:334N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:334N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_335():
    result = parse("DQB1*03:335")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:335") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:335") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_336():
    result = parse("DQB1*03:336")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:336") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:336") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_337():
    result = parse("DQB1*03:337")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:337") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:337") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_338N():
    result = parse("DQB1*03:338N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:338N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:338N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_339N():
    result = parse("DQB1*03:339N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:339N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:339N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_34():
    result = parse("DQB1*03:34")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_340N():
    result = parse("DQB1*03:340N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:340N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:340N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_341():
    result = parse("DQB1*03:341")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:341") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:341") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_342():
    result = parse("DQB1*03:342")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:342") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:342") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_343():
    result = parse("DQB1*03:343")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:343") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:343") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_344():
    result = parse("DQB1*03:344")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:344") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:344") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_345():
    result = parse("DQB1*03:345")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:345") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:345") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_346():
    result = parse("DQB1*03:346")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:346") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:346") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_347():
    result = parse("DQB1*03:347")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:347") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:347") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_348():
    result = parse("DQB1*03:348")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:348") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:348") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_349():
    result = parse("DQB1*03:349")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:349") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:349") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_35():
    result = parse("DQB1*03:35")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_350():
    result = parse("DQB1*03:350")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:350") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:350") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_351():
    result = parse("DQB1*03:351")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:351") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:351") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_352():
    result = parse("DQB1*03:352")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:352") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:352") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_353():
    result = parse("DQB1*03:353")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:353") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:353") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_354N():
    result = parse("DQB1*03:354N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:354N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:354N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_355():
    result = parse("DQB1*03:355")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:355") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:355") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_356N():
    result = parse("DQB1*03:356N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:356N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:356N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_357N():
    result = parse("DQB1*03:357N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:357N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:357N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_358N():
    result = parse("DQB1*03:358N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:358N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:358N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_359():
    result = parse("DQB1*03:359")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:359") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:359") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_36():
    result = parse("DQB1*03:36")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_360():
    result = parse("DQB1*03:360")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:360") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:360") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_361():
    result = parse("DQB1*03:361")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:361") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:361") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_362():
    result = parse("DQB1*03:362")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:362") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:362") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_363():
    result = parse("DQB1*03:363")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:363") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:363") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_364():
    result = parse("DQB1*03:364")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:364") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:364") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_365():
    result = parse("DQB1*03:365")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:365") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:365") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_366():
    result = parse("DQB1*03:366")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:366") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:366") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_367():
    result = parse("DQB1*03:367")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:367") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:367") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_368():
    result = parse("DQB1*03:368")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:368") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:368") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_369():
    result = parse("DQB1*03:369")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:369") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:369") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_37():
    result = parse("DQB1*03:37")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_370():
    result = parse("DQB1*03:370")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:370") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:370") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_371():
    result = parse("DQB1*03:371")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:371") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:371") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_372():
    result = parse("DQB1*03:372")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:372") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:372") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_373():
    result = parse("DQB1*03:373")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:373") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:373") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_374():
    result = parse("DQB1*03:374")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:374") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:374") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_375N():
    result = parse("DQB1*03:375N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:375N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:375N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_376N():
    result = parse("DQB1*03:376N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:376N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:376N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_377():
    result = parse("DQB1*03:377")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:377") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:377") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_378():
    result = parse("DQB1*03:378")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:378") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:378") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_379():
    result = parse("DQB1*03:379")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:379") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:379") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_380():
    result = parse("DQB1*03:380")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:380") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:380") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_381():
    result = parse("DQB1*03:381")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:381") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:381") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_382():
    result = parse("DQB1*03:382")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:382") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:382") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_383():
    result = parse("DQB1*03:383")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:383") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:383") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_384():
    result = parse("DQB1*03:384")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:384") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:384") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_385N():
    result = parse("DQB1*03:385N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:385N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:385N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_386():
    result = parse("DQB1*03:386")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:386") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:386") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_387():
    result = parse("DQB1*03:387")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:387") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:387") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_388():
    result = parse("DQB1*03:388")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:388") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:388") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_389():
    result = parse("DQB1*03:389")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:389") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:389") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_38_01():
    result = parse("DQB1*03:38:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:38:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:38:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_38_02():
    result = parse("DQB1*03:38:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:38:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:38:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_39():
    result = parse("DQB1*03:39")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_390():
    result = parse("DQB1*03:390")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:390") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:390") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_391():
    result = parse("DQB1*03:391")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:391") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:391") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_392():
    result = parse("DQB1*03:392")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:392") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:392") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_393():
    result = parse("DQB1*03:393")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:393") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:393") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_394():
    result = parse("DQB1*03:394")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:394") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:394") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_395():
    result = parse("DQB1*03:395")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:395") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:395") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_396():
    result = parse("DQB1*03:396")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:396") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:396") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_397():
    result = parse("DQB1*03:397")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:397") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:397") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_398():
    result = parse("DQB1*03:398")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:398") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:398") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_399N():
    result = parse("DQB1*03:399N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:399N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:399N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_40():
    result = parse("DQB1*03:40")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_400N():
    result = parse("DQB1*03:400N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:400N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:400N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_401():
    result = parse("DQB1*03:401")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:401") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:401") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_402():
    result = parse("DQB1*03:402")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:402") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:402") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_403N():
    result = parse("DQB1*03:403N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:403N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:403N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_404():
    result = parse("DQB1*03:404")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:404") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:404") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_405():
    result = parse("DQB1*03:405")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:405") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:405") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_406():
    result = parse("DQB1*03:406")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:406") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:406") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_407N():
    result = parse("DQB1*03:407N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:407N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:407N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_408():
    result = parse("DQB1*03:408")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:408") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:408") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_409():
    result = parse("DQB1*03:409")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:409") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:409") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_41():
    result = parse("DQB1*03:41")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_410():
    result = parse("DQB1*03:410")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:410") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:410") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_411N():
    result = parse("DQB1*03:411N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:411N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:411N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_412():
    result = parse("DQB1*03:412")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:412") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:412") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_413():
    result = parse("DQB1*03:413")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:413") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:413") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_414():
    result = parse("DQB1*03:414")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:414") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:414") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_415():
    result = parse("DQB1*03:415")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:415") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:415") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_416():
    result = parse("DQB1*03:416")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:416") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:416") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_417():
    result = parse("DQB1*03:417")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:417") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:417") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_418():
    result = parse("DQB1*03:418")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:418") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:418") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_419():
    result = parse("DQB1*03:419")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:419") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:419") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_42():
    result = parse("DQB1*03:42")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_420():
    result = parse("DQB1*03:420")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:420") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:420") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_421():
    result = parse("DQB1*03:421")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:421") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:421") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_422N():
    result = parse("DQB1*03:422N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:422N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:422N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_423():
    result = parse("DQB1*03:423")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:423") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:423") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_424():
    result = parse("DQB1*03:424")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:424") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:424") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_425():
    result = parse("DQB1*03:425")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:425") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:425") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_426():
    result = parse("DQB1*03:426")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:426") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:426") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_427N():
    result = parse("DQB1*03:427N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:427N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:427N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_428():
    result = parse("DQB1*03:428")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:428") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:428") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_429():
    result = parse("DQB1*03:429")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:429") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:429") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_43():
    result = parse("DQB1*03:43")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_430():
    result = parse("DQB1*03:430")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:430") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:430") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_431():
    result = parse("DQB1*03:431")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:431") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:431") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_432():
    result = parse("DQB1*03:432")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:432") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:432") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_44():
    result = parse("DQB1*03:44")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_45_01():
    result = parse("DQB1*03:45:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:45:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:45:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_45_02():
    result = parse("DQB1*03:45:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:45:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*03:45:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_46():
    result = parse("DQB1*03:46")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_47():
    result = parse("DQB1*03:47")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_48():
    result = parse("DQB1*03:48")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_49():
    result = parse("DQB1*03:49")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_50():
    result = parse("DQB1*03:50")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_51():
    result = parse("DQB1*03:51")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_52():
    result = parse("DQB1*03:52")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_53():
    result = parse("DQB1*03:53")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_54():
    result = parse("DQB1*03:54")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_55():
    result = parse("DQB1*03:55")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_56():
    result = parse("DQB1*03:56")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_57():
    result = parse("DQB1*03:57")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_58():
    result = parse("DQB1*03:58")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_59():
    result = parse("DQB1*03:59")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_60():
    result = parse("DQB1*03:60")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_61():
    result = parse("DQB1*03:61")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_62():
    result = parse("DQB1*03:62")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_63():
    result = parse("DQB1*03:63")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_64():
    result = parse("DQB1*03:64")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_65():
    result = parse("DQB1*03:65")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_66N():
    result = parse("DQB1*03:66N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:66N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:66N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_67():
    result = parse("DQB1*03:67")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_68():
    result = parse("DQB1*03:68")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_69():
    result = parse("DQB1*03:69")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_70():
    result = parse("DQB1*03:70")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_71():
    result = parse("DQB1*03:71")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_72():
    result = parse("DQB1*03:72")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_73():
    result = parse("DQB1*03:73")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_74():
    result = parse("DQB1*03:74")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_75():
    result = parse("DQB1*03:75")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_76():
    result = parse("DQB1*03:76")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_77():
    result = parse("DQB1*03:77")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_78():
    result = parse("DQB1*03:78")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_79():
    result = parse("DQB1*03:79")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_80():
    result = parse("DQB1*03:80")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_81():
    result = parse("DQB1*03:81")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_82():
    result = parse("DQB1*03:82")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_83():
    result = parse("DQB1*03:83")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_84N():
    result = parse("DQB1*03:84N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:84N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:84N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_85():
    result = parse("DQB1*03:85")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_86():
    result = parse("DQB1*03:86")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_87():
    result = parse("DQB1*03:87")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_88():
    result = parse("DQB1*03:88")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_89():
    result = parse("DQB1*03:89")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_90N():
    result = parse("DQB1*03:90N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:90N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:90N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_91Q():
    result = parse("DQB1*03:91Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:91Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:91Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_92():
    result = parse("DQB1*03:92")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_93():
    result = parse("DQB1*03:93")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_94():
    result = parse("DQB1*03:94")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_95N():
    result = parse("DQB1*03:95N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:95N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:95N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_96():
    result = parse("DQB1*03:96")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_97():
    result = parse("DQB1*03:97")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_98():
    result = parse("DQB1*03:98")
    assert result.__class__ is Allele, f'Expected parse("DQB1*03:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_03_99Q():
    result = parse("DQB1*03:99Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*03:99Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*03:99Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_01_01_01():
    result = parse("DQB1*04:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*04:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_01_01_02():
    result = parse("DQB1*04:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*04:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_01_02():
    result = parse("DQB1*04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_01_03():
    result = parse("DQB1*04:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_01_04():
    result = parse("DQB1*04:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_01_05():
    result = parse("DQB1*04:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_01_01():
    result = parse("DQB1*04:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*04:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_01_04():
    result = parse("DQB1*04:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*04:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_01_05():
    result = parse("DQB1*04:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*04:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_01_06():
    result = parse("DQB1*04:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*04:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_01_07():
    result = parse("DQB1*04:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*04:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_01_08():
    result = parse("DQB1*04:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*04:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_01_09():
    result = parse("DQB1*04:02:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*04:02:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_01_10():
    result = parse("DQB1*04:02:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*04:02:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_01_11():
    result = parse("DQB1*04:02:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*04:02:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_02():
    result = parse("DQB1*04:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_03():
    result = parse("DQB1*04:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_04():
    result = parse("DQB1*04:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_05():
    result = parse("DQB1*04:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_06():
    result = parse("DQB1*04:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_07():
    result = parse("DQB1*04:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_08():
    result = parse("DQB1*04:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_09():
    result = parse("DQB1*04:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_10():
    result = parse("DQB1*04:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_11():
    result = parse("DQB1*04:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_12():
    result = parse("DQB1*04:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_13():
    result = parse("DQB1*04:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_14():
    result = parse("DQB1*04:02:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_15():
    result = parse("DQB1*04:02:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_16():
    result = parse("DQB1*04:02:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_17():
    result = parse("DQB1*04:02:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_18():
    result = parse("DQB1*04:02:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_19():
    result = parse("DQB1*04:02:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_02_20():
    result = parse("DQB1*04:02:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:02:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_03_01():
    result = parse("DQB1*04:03:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:03:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:03:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_03_02():
    result = parse("DQB1*04:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_03_03():
    result = parse("DQB1*04:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*04:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_04():
    result = parse("DQB1*04:04")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_05():
    result = parse("DQB1*04:05")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_06():
    result = parse("DQB1*04:06")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_07():
    result = parse("DQB1*04:07")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_08():
    result = parse("DQB1*04:08")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_09():
    result = parse("DQB1*04:09")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_10():
    result = parse("DQB1*04:10")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_11():
    result = parse("DQB1*04:11")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_12():
    result = parse("DQB1*04:12")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_13():
    result = parse("DQB1*04:13")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_14():
    result = parse("DQB1*04:14")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_15():
    result = parse("DQB1*04:15")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_16():
    result = parse("DQB1*04:16")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_17():
    result = parse("DQB1*04:17")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_18():
    result = parse("DQB1*04:18")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_19():
    result = parse("DQB1*04:19")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_20():
    result = parse("DQB1*04:20")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_21():
    result = parse("DQB1*04:21")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_22():
    result = parse("DQB1*04:22")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_23():
    result = parse("DQB1*04:23")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_24():
    result = parse("DQB1*04:24")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_25N():
    result = parse("DQB1*04:25N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:25N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:25N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_26():
    result = parse("DQB1*04:26")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_27():
    result = parse("DQB1*04:27")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_28():
    result = parse("DQB1*04:28")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_29():
    result = parse("DQB1*04:29")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_30():
    result = parse("DQB1*04:30")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_31():
    result = parse("DQB1*04:31")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_32():
    result = parse("DQB1*04:32")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_33():
    result = parse("DQB1*04:33")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_34():
    result = parse("DQB1*04:34")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_35():
    result = parse("DQB1*04:35")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_36N():
    result = parse("DQB1*04:36N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:36N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:36N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_37():
    result = parse("DQB1*04:37")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_38():
    result = parse("DQB1*04:38")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_39():
    result = parse("DQB1*04:39")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_40():
    result = parse("DQB1*04:40")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_41N():
    result = parse("DQB1*04:41N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:41N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:41N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_42():
    result = parse("DQB1*04:42")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_43():
    result = parse("DQB1*04:43")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_44():
    result = parse("DQB1*04:44")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_45():
    result = parse("DQB1*04:45")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_46N():
    result = parse("DQB1*04:46N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:46N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:46N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_47():
    result = parse("DQB1*04:47")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_48():
    result = parse("DQB1*04:48")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_49():
    result = parse("DQB1*04:49")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_50():
    result = parse("DQB1*04:50")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_51():
    result = parse("DQB1*04:51")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_52():
    result = parse("DQB1*04:52")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_53():
    result = parse("DQB1*04:53")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_54():
    result = parse("DQB1*04:54")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_55():
    result = parse("DQB1*04:55")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_56():
    result = parse("DQB1*04:56")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_57():
    result = parse("DQB1*04:57")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_58():
    result = parse("DQB1*04:58")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_59N():
    result = parse("DQB1*04:59N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:59N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:59N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_60():
    result = parse("DQB1*04:60")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_61():
    result = parse("DQB1*04:61")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_62():
    result = parse("DQB1*04:62")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_63():
    result = parse("DQB1*04:63")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_64():
    result = parse("DQB1*04:64")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_65():
    result = parse("DQB1*04:65")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_66():
    result = parse("DQB1*04:66")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_67():
    result = parse("DQB1*04:67")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_68N():
    result = parse("DQB1*04:68N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:68N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:68N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_69():
    result = parse("DQB1*04:69")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_70():
    result = parse("DQB1*04:70")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_71():
    result = parse("DQB1*04:71")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_72():
    result = parse("DQB1*04:72")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_73N():
    result = parse("DQB1*04:73N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*04:73N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:73N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_74():
    result = parse("DQB1*04:74")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_75():
    result = parse("DQB1*04:75")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_76():
    result = parse("DQB1*04:76")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_77():
    result = parse("DQB1*04:77")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_78():
    result = parse("DQB1*04:78")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_04_79():
    result = parse("DQB1*04:79")
    assert result.__class__ is Allele, f'Expected parse("DQB1*04:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*04:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_01_01():
    result = parse("DQB1*05:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_01_02():
    result = parse("DQB1*05:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_01_03():
    result = parse("DQB1*05:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_01_04():
    result = parse("DQB1*05:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_01_05():
    result = parse("DQB1*05:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_01_06():
    result = parse("DQB1*05:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_01_07():
    result = parse("DQB1*05:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_01_08():
    result = parse("DQB1*05:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_01_09():
    result = parse("DQB1*05:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_02():
    result = parse("DQB1*05:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_03():
    result = parse("DQB1*05:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_04():
    result = parse("DQB1*05:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_05():
    result = parse("DQB1*05:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_06():
    result = parse("DQB1*05:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_07():
    result = parse("DQB1*05:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_08():
    result = parse("DQB1*05:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_09():
    result = parse("DQB1*05:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_10():
    result = parse("DQB1*05:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_11():
    result = parse("DQB1*05:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_12():
    result = parse("DQB1*05:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_13():
    result = parse("DQB1*05:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_14():
    result = parse("DQB1*05:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_15():
    result = parse("DQB1*05:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_16():
    result = parse("DQB1*05:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_17():
    result = parse("DQB1*05:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_18():
    result = parse("DQB1*05:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_19():
    result = parse("DQB1*05:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_20():
    result = parse("DQB1*05:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_21():
    result = parse("DQB1*05:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_22():
    result = parse("DQB1*05:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_23():
    result = parse("DQB1*05:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_24_01():
    result = parse("DQB1*05:01:24:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:24:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:01:24:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_24_02():
    result = parse("DQB1*05:01:24:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:24:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:01:24:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_25():
    result = parse("DQB1*05:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_26():
    result = parse("DQB1*05:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_27():
    result = parse("DQB1*05:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_28():
    result = parse("DQB1*05:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_29():
    result = parse("DQB1*05:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_30():
    result = parse("DQB1*05:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_31():
    result = parse("DQB1*05:01:31")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_32():
    result = parse("DQB1*05:01:32")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_33():
    result = parse("DQB1*05:01:33")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_34():
    result = parse("DQB1*05:01:34")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_35():
    result = parse("DQB1*05:01:35")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_36():
    result = parse("DQB1*05:01:36")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_37():
    result = parse("DQB1*05:01:37")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_38():
    result = parse("DQB1*05:01:38")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_39():
    result = parse("DQB1*05:01:39")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_40():
    result = parse("DQB1*05:01:40")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_01_41():
    result = parse("DQB1*05:01:41")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:01:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:01:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_01_01():
    result = parse("DQB1*05:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_01_02():
    result = parse("DQB1*05:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_01_03():
    result = parse("DQB1*05:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_01_04():
    result = parse("DQB1*05:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_01_05():
    result = parse("DQB1*05:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_01_06():
    result = parse("DQB1*05:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_01_07():
    result = parse("DQB1*05:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_02():
    result = parse("DQB1*05:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_03():
    result = parse("DQB1*05:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_04():
    result = parse("DQB1*05:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_05():
    result = parse("DQB1*05:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_06():
    result = parse("DQB1*05:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_07():
    result = parse("DQB1*05:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_08():
    result = parse("DQB1*05:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_09():
    result = parse("DQB1*05:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_10():
    result = parse("DQB1*05:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_11():
    result = parse("DQB1*05:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_12():
    result = parse("DQB1*05:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_13():
    result = parse("DQB1*05:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_14():
    result = parse("DQB1*05:02:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_15():
    result = parse("DQB1*05:02:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_16():
    result = parse("DQB1*05:02:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_17():
    result = parse("DQB1*05:02:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_18():
    result = parse("DQB1*05:02:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_19():
    result = parse("DQB1*05:02:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_20():
    result = parse("DQB1*05:02:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_21():
    result = parse("DQB1*05:02:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_22():
    result = parse("DQB1*05:02:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_02_23():
    result = parse("DQB1*05:02:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:02:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_01_01():
    result = parse("DQB1*05:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_01_02():
    result = parse("DQB1*05:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_01_03():
    result = parse("DQB1*05:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_01_04():
    result = parse("DQB1*05:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_01_05():
    result = parse("DQB1*05:03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*05:03:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_02():
    result = parse("DQB1*05:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_03():
    result = parse("DQB1*05:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_04():
    result = parse("DQB1*05:03:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_05():
    result = parse("DQB1*05:03:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_06():
    result = parse("DQB1*05:03:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_07():
    result = parse("DQB1*05:03:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_08():
    result = parse("DQB1*05:03:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_09():
    result = parse("DQB1*05:03:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_10():
    result = parse("DQB1*05:03:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_11():
    result = parse("DQB1*05:03:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_12():
    result = parse("DQB1*05:03:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_13():
    result = parse("DQB1*05:03:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_14():
    result = parse("DQB1*05:03:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_15():
    result = parse("DQB1*05:03:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_16():
    result = parse("DQB1*05:03:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_17():
    result = parse("DQB1*05:03:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_18():
    result = parse("DQB1*05:03:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_19():
    result = parse("DQB1*05:03:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_20():
    result = parse("DQB1*05:03:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_21():
    result = parse("DQB1*05:03:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_22():
    result = parse("DQB1*05:03:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_03_23():
    result = parse("DQB1*05:03:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:03:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:03:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_04():
    result = parse("DQB1*05:04")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_05_01():
    result = parse("DQB1*05:05:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:05:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_05_02():
    result = parse("DQB1*05:05:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:05:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_06_01():
    result = parse("DQB1*05:06:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:06:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_06_02():
    result = parse("DQB1*05:06:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:06:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_07():
    result = parse("DQB1*05:07")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_08():
    result = parse("DQB1*05:08")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:08") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_09():
    result = parse("DQB1*05:09")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_10():
    result = parse("DQB1*05:10")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_100():
    result = parse("DQB1*05:100")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_101():
    result = parse("DQB1*05:101")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_102():
    result = parse("DQB1*05:102")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:102") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_103():
    result = parse("DQB1*05:103")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_104():
    result = parse("DQB1*05:104")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_105():
    result = parse("DQB1*05:105")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_106():
    result = parse("DQB1*05:106")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_107():
    result = parse("DQB1*05:107")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_108():
    result = parse("DQB1*05:108")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_109():
    result = parse("DQB1*05:109")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_110N():
    result = parse("DQB1*05:110N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:110N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:110N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_111():
    result = parse("DQB1*05:111")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_112():
    result = parse("DQB1*05:112")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:112") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_113():
    result = parse("DQB1*05:113")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_114():
    result = parse("DQB1*05:114")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_115():
    result = parse("DQB1*05:115")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:115") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_116():
    result = parse("DQB1*05:116")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_117():
    result = parse("DQB1*05:117")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_118():
    result = parse("DQB1*05:118")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:118") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:118") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_119():
    result = parse("DQB1*05:119")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:119") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_11_01():
    result = parse("DQB1*05:11:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:11:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:11:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_11_02():
    result = parse("DQB1*05:11:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:11:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:11:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_12():
    result = parse("DQB1*05:12")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_120():
    result = parse("DQB1*05:120")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:120") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_121():
    result = parse("DQB1*05:121")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:121") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_122():
    result = parse("DQB1*05:122")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:122") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_123():
    result = parse("DQB1*05:123")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:123") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_124():
    result = parse("DQB1*05:124")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:124") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_125():
    result = parse("DQB1*05:125")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:125") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_126():
    result = parse("DQB1*05:126")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:126") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_127():
    result = parse("DQB1*05:127")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:127") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_128N():
    result = parse("DQB1*05:128N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:128N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:128N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_129():
    result = parse("DQB1*05:129")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:129") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_13():
    result = parse("DQB1*05:13")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_130():
    result = parse("DQB1*05:130")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:130") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_131():
    result = parse("DQB1*05:131")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:131") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_132Q():
    result = parse("DQB1*05:132Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:132Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:132Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_133():
    result = parse("DQB1*05:133")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:133") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_134():
    result = parse("DQB1*05:134")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:134") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_135():
    result = parse("DQB1*05:135")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:135") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_136():
    result = parse("DQB1*05:136")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:136") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_137():
    result = parse("DQB1*05:137")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:137") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_138():
    result = parse("DQB1*05:138")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:138") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_139():
    result = parse("DQB1*05:139")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:139") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_14():
    result = parse("DQB1*05:14")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_140():
    result = parse("DQB1*05:140")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:140") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_141():
    result = parse("DQB1*05:141")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:141") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_142():
    result = parse("DQB1*05:142")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:142") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_143():
    result = parse("DQB1*05:143")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:143") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_144():
    result = parse("DQB1*05:144")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:144") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:144") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_145():
    result = parse("DQB1*05:145")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:145") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_146():
    result = parse("DQB1*05:146")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:146") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:146") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_147():
    result = parse("DQB1*05:147")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:147") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_148():
    result = parse("DQB1*05:148")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:148") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_149():
    result = parse("DQB1*05:149")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:149") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_15():
    result = parse("DQB1*05:15")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_150():
    result = parse("DQB1*05:150")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:150") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_151():
    result = parse("DQB1*05:151")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:151") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_152():
    result = parse("DQB1*05:152")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:152") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_153():
    result = parse("DQB1*05:153")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:153") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:153") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_154():
    result = parse("DQB1*05:154")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:154") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_155():
    result = parse("DQB1*05:155")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:155") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_156():
    result = parse("DQB1*05:156")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:156") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_157():
    result = parse("DQB1*05:157")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:157") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_158():
    result = parse("DQB1*05:158")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:158") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:158") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_159():
    result = parse("DQB1*05:159")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:159") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_16():
    result = parse("DQB1*05:16")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_160():
    result = parse("DQB1*05:160")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:160") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_161():
    result = parse("DQB1*05:161")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:161") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_162():
    result = parse("DQB1*05:162")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:162") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_163():
    result = parse("DQB1*05:163")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:163") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_164():
    result = parse("DQB1*05:164")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:164") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_165():
    result = parse("DQB1*05:165")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:165") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_166():
    result = parse("DQB1*05:166")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:166") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_167():
    result = parse("DQB1*05:167")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:167") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_168():
    result = parse("DQB1*05:168")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:168") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_169():
    result = parse("DQB1*05:169")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:169") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_17():
    result = parse("DQB1*05:17")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_170():
    result = parse("DQB1*05:170")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:170") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_171():
    result = parse("DQB1*05:171")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:171") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_172():
    result = parse("DQB1*05:172")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:172") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_173():
    result = parse("DQB1*05:173")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:173") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_174():
    result = parse("DQB1*05:174")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:174") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_175():
    result = parse("DQB1*05:175")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:175") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_176():
    result = parse("DQB1*05:176")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:176") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_177():
    result = parse("DQB1*05:177")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:177") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_178():
    result = parse("DQB1*05:178")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:178") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_179():
    result = parse("DQB1*05:179")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:179") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:179") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_18():
    result = parse("DQB1*05:18")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_180():
    result = parse("DQB1*05:180")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:180") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_181():
    result = parse("DQB1*05:181")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:181") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_182():
    result = parse("DQB1*05:182")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:182") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_183():
    result = parse("DQB1*05:183")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:183") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_184():
    result = parse("DQB1*05:184")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:184") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_185N():
    result = parse("DQB1*05:185N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:185N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:185N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_186():
    result = parse("DQB1*05:186")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:186") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_187():
    result = parse("DQB1*05:187")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:187") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_188():
    result = parse("DQB1*05:188")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:188") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_189():
    result = parse("DQB1*05:189")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:189") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_19():
    result = parse("DQB1*05:19")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_190():
    result = parse("DQB1*05:190")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:190") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:190") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_191():
    result = parse("DQB1*05:191")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:191") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_192():
    result = parse("DQB1*05:192")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:192") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_193():
    result = parse("DQB1*05:193")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:193") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:193") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_194():
    result = parse("DQB1*05:194")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:194") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_195():
    result = parse("DQB1*05:195")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:195") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_196():
    result = parse("DQB1*05:196")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:196") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_197():
    result = parse("DQB1*05:197")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:197") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_198():
    result = parse("DQB1*05:198")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:198") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_199():
    result = parse("DQB1*05:199")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:199") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_20():
    result = parse("DQB1*05:20")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_200():
    result = parse("DQB1*05:200")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:200") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_201():
    result = parse("DQB1*05:201")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:201") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_202():
    result = parse("DQB1*05:202")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:202") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_203():
    result = parse("DQB1*05:203")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:203") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_204():
    result = parse("DQB1*05:204")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:204") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_205():
    result = parse("DQB1*05:205")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:205") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_206N():
    result = parse("DQB1*05:206N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:206N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:206N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_207():
    result = parse("DQB1*05:207")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:207") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_208N():
    result = parse("DQB1*05:208N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:208N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:208N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_209():
    result = parse("DQB1*05:209")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:209") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_21():
    result = parse("DQB1*05:21")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_210():
    result = parse("DQB1*05:210")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:210") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_211():
    result = parse("DQB1*05:211")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:211") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_212():
    result = parse("DQB1*05:212")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:212") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_213():
    result = parse("DQB1*05:213")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:213") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_214():
    result = parse("DQB1*05:214")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:214") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_215N():
    result = parse("DQB1*05:215N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:215N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:215N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_216():
    result = parse("DQB1*05:216")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:216") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:216") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_217():
    result = parse("DQB1*05:217")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:217") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_218():
    result = parse("DQB1*05:218")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:218") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_219():
    result = parse("DQB1*05:219")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:219") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_22():
    result = parse("DQB1*05:22")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_220():
    result = parse("DQB1*05:220")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:220") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:220") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_221():
    result = parse("DQB1*05:221")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:221") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_222():
    result = parse("DQB1*05:222")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:222") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_223():
    result = parse("DQB1*05:223")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:223") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_224N():
    result = parse("DQB1*05:224N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:224N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:224N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_225():
    result = parse("DQB1*05:225")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:225") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_226():
    result = parse("DQB1*05:226")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:226") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_227():
    result = parse("DQB1*05:227")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:227") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_228():
    result = parse("DQB1*05:228")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:228") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_229():
    result = parse("DQB1*05:229")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:229") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_23():
    result = parse("DQB1*05:23")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_230():
    result = parse("DQB1*05:230")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:230") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_231():
    result = parse("DQB1*05:231")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:231") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_232():
    result = parse("DQB1*05:232")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:232") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_233():
    result = parse("DQB1*05:233")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:233") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_234():
    result = parse("DQB1*05:234")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:234") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_235N():
    result = parse("DQB1*05:235N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:235N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:235N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_236N():
    result = parse("DQB1*05:236N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:236N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:236N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_237():
    result = parse("DQB1*05:237")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:237") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_238():
    result = parse("DQB1*05:238")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:238") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_239():
    result = parse("DQB1*05:239")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:239") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_24():
    result = parse("DQB1*05:24")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_240():
    result = parse("DQB1*05:240")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:240") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_241():
    result = parse("DQB1*05:241")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:241") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_242():
    result = parse("DQB1*05:242")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:242") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_243():
    result = parse("DQB1*05:243")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:243") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_244():
    result = parse("DQB1*05:244")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:244") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_245():
    result = parse("DQB1*05:245")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:245") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_246():
    result = parse("DQB1*05:246")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:246") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_247():
    result = parse("DQB1*05:247")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:247") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_248():
    result = parse("DQB1*05:248")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:248") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_249():
    result = parse("DQB1*05:249")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:249") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_25():
    result = parse("DQB1*05:25")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_250():
    result = parse("DQB1*05:250")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:250") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_251():
    result = parse("DQB1*05:251")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:251") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_252():
    result = parse("DQB1*05:252")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:252") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:252") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_253():
    result = parse("DQB1*05:253")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:253") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_254():
    result = parse("DQB1*05:254")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:254") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_26():
    result = parse("DQB1*05:26")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_27():
    result = parse("DQB1*05:27")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_28():
    result = parse("DQB1*05:28")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_29():
    result = parse("DQB1*05:29")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_30():
    result = parse("DQB1*05:30")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_31():
    result = parse("DQB1*05:31")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_32():
    result = parse("DQB1*05:32")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:32") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:32") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_33():
    result = parse("DQB1*05:33")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_34():
    result = parse("DQB1*05:34")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_35():
    result = parse("DQB1*05:35")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_36():
    result = parse("DQB1*05:36")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_37():
    result = parse("DQB1*05:37")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_38():
    result = parse("DQB1*05:38")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_39():
    result = parse("DQB1*05:39")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_40():
    result = parse("DQB1*05:40")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_41N():
    result = parse("DQB1*05:41N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:41N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:41N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_42():
    result = parse("DQB1*05:42")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_43_01():
    result = parse("DQB1*05:43:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:43:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:43:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_43_02():
    result = parse("DQB1*05:43:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:43:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:43:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_44():
    result = parse("DQB1*05:44")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_45():
    result = parse("DQB1*05:45")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_46():
    result = parse("DQB1*05:46")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_47():
    result = parse("DQB1*05:47")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_48():
    result = parse("DQB1*05:48")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_49():
    result = parse("DQB1*05:49")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_50():
    result = parse("DQB1*05:50")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_51():
    result = parse("DQB1*05:51")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_52():
    result = parse("DQB1*05:52")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_53():
    result = parse("DQB1*05:53")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_54():
    result = parse("DQB1*05:54")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:54") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:54") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_55():
    result = parse("DQB1*05:55")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_56():
    result = parse("DQB1*05:56")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_57():
    result = parse("DQB1*05:57")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_58():
    result = parse("DQB1*05:58")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_59():
    result = parse("DQB1*05:59")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_60():
    result = parse("DQB1*05:60")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_61():
    result = parse("DQB1*05:61")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_62():
    result = parse("DQB1*05:62")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_63():
    result = parse("DQB1*05:63")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_64():
    result = parse("DQB1*05:64")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_65():
    result = parse("DQB1*05:65")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_66_01():
    result = parse("DQB1*05:66:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:66:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:66:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_66_02():
    result = parse("DQB1*05:66:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:66:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:66:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_67():
    result = parse("DQB1*05:67")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_68():
    result = parse("DQB1*05:68")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_69():
    result = parse("DQB1*05:69")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_70():
    result = parse("DQB1*05:70")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_71():
    result = parse("DQB1*05:71")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_72():
    result = parse("DQB1*05:72")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_73():
    result = parse("DQB1*05:73")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_74():
    result = parse("DQB1*05:74")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_75():
    result = parse("DQB1*05:75")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_76():
    result = parse("DQB1*05:76")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_77():
    result = parse("DQB1*05:77")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_78():
    result = parse("DQB1*05:78")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_79():
    result = parse("DQB1*05:79")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_80():
    result = parse("DQB1*05:80")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_81():
    result = parse("DQB1*05:81")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_82():
    result = parse("DQB1*05:82")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_83():
    result = parse("DQB1*05:83")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_84():
    result = parse("DQB1*05:84")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_85():
    result = parse("DQB1*05:85")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_86():
    result = parse("DQB1*05:86")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_87Q():
    result = parse("DQB1*05:87Q")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:87Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:87Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_88():
    result = parse("DQB1*05:88")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_89_01():
    result = parse("DQB1*05:89:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:89:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:89:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_89_02():
    result = parse("DQB1*05:89:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:89:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*05:89:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_90N():
    result = parse("DQB1*05:90N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*05:90N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:90N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_91():
    result = parse("DQB1*05:91")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_92():
    result = parse("DQB1*05:92")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_93():
    result = parse("DQB1*05:93")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_94():
    result = parse("DQB1*05:94")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_95():
    result = parse("DQB1*05:95")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_96():
    result = parse("DQB1*05:96")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_97():
    result = parse("DQB1*05:97")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_98():
    result = parse("DQB1*05:98")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_05_99():
    result = parse("DQB1*05:99")
    assert result.__class__ is Allele, f'Expected parse("DQB1*05:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*05:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_01_01():
    result = parse("DQB1*06:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_01_02():
    result = parse("DQB1*06:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_02():
    result = parse("DQB1*06:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_03():
    result = parse("DQB1*06:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_04():
    result = parse("DQB1*06:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_05():
    result = parse("DQB1*06:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_06():
    result = parse("DQB1*06:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_07():
    result = parse("DQB1*06:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_08():
    result = parse("DQB1*06:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_09():
    result = parse("DQB1*06:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_10():
    result = parse("DQB1*06:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_11():
    result = parse("DQB1*06:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_12():
    result = parse("DQB1*06:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_13():
    result = parse("DQB1*06:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_14():
    result = parse("DQB1*06:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_15():
    result = parse("DQB1*06:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_16():
    result = parse("DQB1*06:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_17():
    result = parse("DQB1*06:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_18():
    result = parse("DQB1*06:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_19():
    result = parse("DQB1*06:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_20():
    result = parse("DQB1*06:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_21():
    result = parse("DQB1*06:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_22():
    result = parse("DQB1*06:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_23():
    result = parse("DQB1*06:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_24():
    result = parse("DQB1*06:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_25():
    result = parse("DQB1*06:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_26():
    result = parse("DQB1*06:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_01_27():
    result = parse("DQB1*06:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_01_01():
    result = parse("DQB1*06:02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:02:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_01_02():
    result = parse("DQB1*06:02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:02:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_01_03():
    result = parse("DQB1*06:02:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:02:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_01_04():
    result = parse("DQB1*06:02:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:02:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_01_05():
    result = parse("DQB1*06:02:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:02:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_01_06():
    result = parse("DQB1*06:02:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:02:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_01_07():
    result = parse("DQB1*06:02:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:02:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_01_08():
    result = parse("DQB1*06:02:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:02:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_02():
    result = parse("DQB1*06:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_03():
    result = parse("DQB1*06:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_04():
    result = parse("DQB1*06:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_05():
    result = parse("DQB1*06:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_06():
    result = parse("DQB1*06:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_07():
    result = parse("DQB1*06:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_08():
    result = parse("DQB1*06:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_09():
    result = parse("DQB1*06:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_10():
    result = parse("DQB1*06:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_11():
    result = parse("DQB1*06:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_12():
    result = parse("DQB1*06:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_13():
    result = parse("DQB1*06:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_14():
    result = parse("DQB1*06:02:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_15():
    result = parse("DQB1*06:02:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_16():
    result = parse("DQB1*06:02:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_17():
    result = parse("DQB1*06:02:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_18():
    result = parse("DQB1*06:02:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_19():
    result = parse("DQB1*06:02:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_20():
    result = parse("DQB1*06:02:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_21():
    result = parse("DQB1*06:02:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_22():
    result = parse("DQB1*06:02:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_23():
    result = parse("DQB1*06:02:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_24():
    result = parse("DQB1*06:02:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_25():
    result = parse("DQB1*06:02:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_26():
    result = parse("DQB1*06:02:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_27():
    result = parse("DQB1*06:02:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_28():
    result = parse("DQB1*06:02:28")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_29():
    result = parse("DQB1*06:02:29")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_30():
    result = parse("DQB1*06:02:30")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_31():
    result = parse("DQB1*06:02:31")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_32():
    result = parse("DQB1*06:02:32")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_33():
    result = parse("DQB1*06:02:33")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_34():
    result = parse("DQB1*06:02:34")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_35():
    result = parse("DQB1*06:02:35")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_36():
    result = parse("DQB1*06:02:36")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_37():
    result = parse("DQB1*06:02:37")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_38():
    result = parse("DQB1*06:02:38")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_39():
    result = parse("DQB1*06:02:39")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_40():
    result = parse("DQB1*06:02:40")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:40") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:40") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_41():
    result = parse("DQB1*06:02:41")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:41") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:41") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_42():
    result = parse("DQB1*06:02:42")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:42") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:42") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_43():
    result = parse("DQB1*06:02:43")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:43") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:43") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_02_44():
    result = parse("DQB1*06:02:44")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:02:44") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:02:44") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_01_01():
    result = parse("DQB1*06:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_01_02():
    result = parse("DQB1*06:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_01_03():
    result = parse("DQB1*06:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_01_04():
    result = parse("DQB1*06:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_01_05():
    result = parse("DQB1*06:03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:03:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_01_06():
    result = parse("DQB1*06:03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:03:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_02():
    result = parse("DQB1*06:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_03():
    result = parse("DQB1*06:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_04():
    result = parse("DQB1*06:03:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_05():
    result = parse("DQB1*06:03:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_06():
    result = parse("DQB1*06:03:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_07():
    result = parse("DQB1*06:03:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_08():
    result = parse("DQB1*06:03:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_09():
    result = parse("DQB1*06:03:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_10():
    result = parse("DQB1*06:03:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_11():
    result = parse("DQB1*06:03:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_12():
    result = parse("DQB1*06:03:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_13():
    result = parse("DQB1*06:03:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_14():
    result = parse("DQB1*06:03:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_15():
    result = parse("DQB1*06:03:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_16():
    result = parse("DQB1*06:03:16")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_17():
    result = parse("DQB1*06:03:17")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_18():
    result = parse("DQB1*06:03:18")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_19():
    result = parse("DQB1*06:03:19")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_20():
    result = parse("DQB1*06:03:20")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_21():
    result = parse("DQB1*06:03:21")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_22():
    result = parse("DQB1*06:03:22")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_23():
    result = parse("DQB1*06:03:23")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_24():
    result = parse("DQB1*06:03:24")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_25():
    result = parse("DQB1*06:03:25")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_26():
    result = parse("DQB1*06:03:26")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_27():
    result = parse("DQB1*06:03:27")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_28():
    result = parse("DQB1*06:03:28")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_29():
    result = parse("DQB1*06:03:29")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_30():
    result = parse("DQB1*06:03:30")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_31():
    result = parse("DQB1*06:03:31")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:31") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_32():
    result = parse("DQB1*06:03:32")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:32") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_33():
    result = parse("DQB1*06:03:33")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:33") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_34():
    result = parse("DQB1*06:03:34")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:34") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_35():
    result = parse("DQB1*06:03:35")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:35") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_36():
    result = parse("DQB1*06:03:36")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:36") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:36") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_37():
    result = parse("DQB1*06:03:37")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:37") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:37") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_38():
    result = parse("DQB1*06:03:38")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:38") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:38") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_03_39():
    result = parse("DQB1*06:03:39")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:03:39") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:03:39") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_04_01_01():
    result = parse("DQB1*06:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_04_01_02():
    result = parse("DQB1*06:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_04_02():
    result = parse("DQB1*06:04:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:04:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_04_03():
    result = parse("DQB1*06:04:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:04:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_04_04():
    result = parse("DQB1*06:04:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:04:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:04:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_04_05():
    result = parse("DQB1*06:04:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:04:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:04:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_04_06():
    result = parse("DQB1*06:04:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:04:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:04:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_04_07():
    result = parse("DQB1*06:04:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:04:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:04:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_04_08():
    result = parse("DQB1*06:04:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:04:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:04:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_04_09():
    result = parse("DQB1*06:04:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:04:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:04:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_04_10():
    result = parse("DQB1*06:04:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:04:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:04:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_04_11():
    result = parse("DQB1*06:04:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:04:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:04:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_04_12():
    result = parse("DQB1*06:04:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:04:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:04:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_04_13():
    result = parse("DQB1*06:04:13")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:04:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:04:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_04_14():
    result = parse("DQB1*06:04:14")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:04:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:04:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_04_15():
    result = parse("DQB1*06:04:15")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:04:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:04:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_05_01():
    result = parse("DQB1*06:05:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:05:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_05_02():
    result = parse("DQB1*06:05:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:05:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_06():
    result = parse("DQB1*06:06")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_07_01():
    result = parse("DQB1*06:07:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:07:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_07_02():
    result = parse("DQB1*06:07:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:07:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_08_01():
    result = parse("DQB1*06:08:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:08:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:08:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_08_02():
    result = parse("DQB1*06:08:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:08:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:08:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_08_03():
    result = parse("DQB1*06:08:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:08:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:08:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_09_01_01():
    result = parse("DQB1*06:09:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:09:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:09:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_09_01_02():
    result = parse("DQB1*06:09:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:09:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("DQB1*06:09:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_09_02():
    result = parse("DQB1*06:09:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:09:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:09:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_09_03():
    result = parse("DQB1*06:09:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:09:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:09:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_09_04():
    result = parse("DQB1*06:09:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:09:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:09:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_09_05():
    result = parse("DQB1*06:09:05")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:09:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:09:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_09_06():
    result = parse("DQB1*06:09:06")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:09:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:09:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_09_07():
    result = parse("DQB1*06:09:07")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:09:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:09:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_09_08():
    result = parse("DQB1*06:09:08")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:09:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:09:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_09_09():
    result = parse("DQB1*06:09:09")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:09:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:09:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_09_10():
    result = parse("DQB1*06:09:10")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:09:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:09:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_09_11():
    result = parse("DQB1*06:09:11")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:09:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:09:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_09_12():
    result = parse("DQB1*06:09:12")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:09:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:09:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_10():
    result = parse("DQB1*06:10")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_100():
    result = parse("DQB1*06:100")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:100") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_101():
    result = parse("DQB1*06:101")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:101") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_102N():
    result = parse("DQB1*06:102N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:102N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:102N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_103():
    result = parse("DQB1*06:103")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:103") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_104():
    result = parse("DQB1*06:104")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:104") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_105():
    result = parse("DQB1*06:105")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:105") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_106():
    result = parse("DQB1*06:106")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:106") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_107():
    result = parse("DQB1*06:107")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:107") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_108():
    result = parse("DQB1*06:108")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:108") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_109():
    result = parse("DQB1*06:109")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:109") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_110():
    result = parse("DQB1*06:110")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:110") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_111():
    result = parse("DQB1*06:111")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:111") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_112N():
    result = parse("DQB1*06:112N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:112N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:112N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_113():
    result = parse("DQB1*06:113")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:113") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_114():
    result = parse("DQB1*06:114")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:114") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_115():
    result = parse("DQB1*06:115")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:115") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_116():
    result = parse("DQB1*06:116")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:116") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:116") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_117():
    result = parse("DQB1*06:117")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:117") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:117") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_118_01():
    result = parse("DQB1*06:118:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:118:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:118:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_118_02():
    result = parse("DQB1*06:118:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:118:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:118:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_118_03():
    result = parse("DQB1*06:118:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:118:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:118:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_119():
    result = parse("DQB1*06:119")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:119") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:119") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_11_01():
    result = parse("DQB1*06:11:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:11:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:11:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_11_02():
    result = parse("DQB1*06:11:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:11:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:11:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_11_03():
    result = parse("DQB1*06:11:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:11:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:11:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_11_04():
    result = parse("DQB1*06:11:04")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:11:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:11:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_12():
    result = parse("DQB1*06:12")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_120():
    result = parse("DQB1*06:120")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:120") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:120") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_121():
    result = parse("DQB1*06:121")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:121") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:121") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_122():
    result = parse("DQB1*06:122")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:122") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:122") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_123():
    result = parse("DQB1*06:123")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:123") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:123") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_124():
    result = parse("DQB1*06:124")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:124") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:124") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_125():
    result = parse("DQB1*06:125")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:125") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:125") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_126():
    result = parse("DQB1*06:126")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:126") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:126") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_127():
    result = parse("DQB1*06:127")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:127") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:127") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_128():
    result = parse("DQB1*06:128")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:128") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:128") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_129():
    result = parse("DQB1*06:129")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:129") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:129") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_130():
    result = parse("DQB1*06:130")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:130") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:130") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_131():
    result = parse("DQB1*06:131")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:131") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:131") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_132():
    result = parse("DQB1*06:132")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:132") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:132") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_133():
    result = parse("DQB1*06:133")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:133") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:133") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_134():
    result = parse("DQB1*06:134")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:134") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:134") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_135():
    result = parse("DQB1*06:135")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:135") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:135") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_136():
    result = parse("DQB1*06:136")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:136") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:136") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_137():
    result = parse("DQB1*06:137")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:137") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:137") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_138():
    result = parse("DQB1*06:138")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:138") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:138") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_139():
    result = parse("DQB1*06:139")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:139") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:139") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_13_01():
    result = parse("DQB1*06:13:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:13:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:13:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_13_02():
    result = parse("DQB1*06:13:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:13:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:13:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_13_03():
    result = parse("DQB1*06:13:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:13:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:13:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_140():
    result = parse("DQB1*06:140")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:140") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:140") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_141():
    result = parse("DQB1*06:141")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:141") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:141") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_142():
    result = parse("DQB1*06:142")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:142") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:142") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_143():
    result = parse("DQB1*06:143")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:143") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:143") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_144N():
    result = parse("DQB1*06:144N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:144N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:144N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_145():
    result = parse("DQB1*06:145")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:145") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:145") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_146_01():
    result = parse("DQB1*06:146:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:146:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:146:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_146_02():
    result = parse("DQB1*06:146:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:146:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:146:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_147():
    result = parse("DQB1*06:147")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:147") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:147") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_148():
    result = parse("DQB1*06:148")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:148") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:148") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_149():
    result = parse("DQB1*06:149")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:149") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:149") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_14_01():
    result = parse("DQB1*06:14:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:14:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:14:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_14_02():
    result = parse("DQB1*06:14:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:14:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:14:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_14_03():
    result = parse("DQB1*06:14:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:14:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:14:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_150():
    result = parse("DQB1*06:150")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:150") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:150") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_151():
    result = parse("DQB1*06:151")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:151") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:151") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_152():
    result = parse("DQB1*06:152")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:152") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:152") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_153_01():
    result = parse("DQB1*06:153:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:153:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:153:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_153_02():
    result = parse("DQB1*06:153:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:153:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:153:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_154():
    result = parse("DQB1*06:154")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:154") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:154") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_155():
    result = parse("DQB1*06:155")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:155") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:155") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_156():
    result = parse("DQB1*06:156")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:156") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:156") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_157():
    result = parse("DQB1*06:157")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:157") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:157") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_158N():
    result = parse("DQB1*06:158N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:158N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:158N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_159():
    result = parse("DQB1*06:159")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:159") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:159") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_15_01():
    result = parse("DQB1*06:15:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:15:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:15:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_15_02():
    result = parse("DQB1*06:15:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:15:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:15:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_16():
    result = parse("DQB1*06:16")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_160():
    result = parse("DQB1*06:160")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:160") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:160") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_161():
    result = parse("DQB1*06:161")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:161") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:161") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_162():
    result = parse("DQB1*06:162")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:162") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:162") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_163():
    result = parse("DQB1*06:163")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:163") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:163") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_164():
    result = parse("DQB1*06:164")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:164") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:164") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_165():
    result = parse("DQB1*06:165")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:165") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:165") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_166():
    result = parse("DQB1*06:166")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:166") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:166") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_167():
    result = parse("DQB1*06:167")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:167") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:167") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_168():
    result = parse("DQB1*06:168")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:168") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:168") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_169():
    result = parse("DQB1*06:169")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:169") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:169") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_17():
    result = parse("DQB1*06:17")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_170():
    result = parse("DQB1*06:170")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:170") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:170") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_171():
    result = parse("DQB1*06:171")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:171") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:171") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_172():
    result = parse("DQB1*06:172")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:172") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:172") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_173():
    result = parse("DQB1*06:173")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:173") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:173") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_174():
    result = parse("DQB1*06:174")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:174") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:174") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_175():
    result = parse("DQB1*06:175")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:175") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:175") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_176():
    result = parse("DQB1*06:176")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:176") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:176") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_177():
    result = parse("DQB1*06:177")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:177") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:177") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_178():
    result = parse("DQB1*06:178")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:178") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:178") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_179N():
    result = parse("DQB1*06:179N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:179N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:179N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_180():
    result = parse("DQB1*06:180")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:180") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:180") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_181():
    result = parse("DQB1*06:181")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:181") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:181") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_182():
    result = parse("DQB1*06:182")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:182") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:182") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_183():
    result = parse("DQB1*06:183")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:183") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:183") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_184():
    result = parse("DQB1*06:184")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:184") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:184") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_185():
    result = parse("DQB1*06:185")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:185") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:185") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_186():
    result = parse("DQB1*06:186")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:186") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:186") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_187():
    result = parse("DQB1*06:187")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:187") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:187") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_188():
    result = parse("DQB1*06:188")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:188") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:188") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_189():
    result = parse("DQB1*06:189")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:189") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:189") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_18_01():
    result = parse("DQB1*06:18:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:18:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:18:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_18_02():
    result = parse("DQB1*06:18:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:18:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:18:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_190_01():
    result = parse("DQB1*06:190:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:190:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:190:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_190_02():
    result = parse("DQB1*06:190:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:190:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:190:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_191():
    result = parse("DQB1*06:191")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:191") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:191") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_192():
    result = parse("DQB1*06:192")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:192") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:192") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_193N():
    result = parse("DQB1*06:193N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:193N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:193N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_194():
    result = parse("DQB1*06:194")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:194") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:194") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_195():
    result = parse("DQB1*06:195")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:195") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:195") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_196():
    result = parse("DQB1*06:196")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:196") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:196") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_197():
    result = parse("DQB1*06:197")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:197") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:197") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_198():
    result = parse("DQB1*06:198")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:198") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:198") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_199():
    result = parse("DQB1*06:199")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:199") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:199") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_19_01():
    result = parse("DQB1*06:19:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:19:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:19:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_19_02():
    result = parse("DQB1*06:19:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:19:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:19:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_20():
    result = parse("DQB1*06:20")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_200():
    result = parse("DQB1*06:200")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:200") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:200") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_201():
    result = parse("DQB1*06:201")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:201") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:201") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_202():
    result = parse("DQB1*06:202")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:202") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:202") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_203():
    result = parse("DQB1*06:203")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:203") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:203") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_204():
    result = parse("DQB1*06:204")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:204") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:204") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_205():
    result = parse("DQB1*06:205")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:205") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:205") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_206_01():
    result = parse("DQB1*06:206:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:206:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:206:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_206_02():
    result = parse("DQB1*06:206:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:206:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:206:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_207():
    result = parse("DQB1*06:207")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:207") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:207") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_208():
    result = parse("DQB1*06:208")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:208") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:208") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_209():
    result = parse("DQB1*06:209")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:209") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:209") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_21():
    result = parse("DQB1*06:21")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:21") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:21") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_210():
    result = parse("DQB1*06:210")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:210") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:210") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_211():
    result = parse("DQB1*06:211")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:211") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:211") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_212():
    result = parse("DQB1*06:212")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:212") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:212") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_213():
    result = parse("DQB1*06:213")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:213") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:213") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_214():
    result = parse("DQB1*06:214")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:214") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:214") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_215():
    result = parse("DQB1*06:215")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:215") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:215") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_216N():
    result = parse("DQB1*06:216N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:216N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:216N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_217():
    result = parse("DQB1*06:217")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:217") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:217") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_218():
    result = parse("DQB1*06:218")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:218") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:218") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_219():
    result = parse("DQB1*06:219")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:219") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:219") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_221():
    result = parse("DQB1*06:221")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:221") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:221") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_222():
    result = parse("DQB1*06:222")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:222") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:222") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_223():
    result = parse("DQB1*06:223")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:223") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:223") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_224():
    result = parse("DQB1*06:224")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:224") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:224") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_225():
    result = parse("DQB1*06:225")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:225") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:225") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_226():
    result = parse("DQB1*06:226")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:226") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:226") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_227():
    result = parse("DQB1*06:227")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:227") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:227") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_228():
    result = parse("DQB1*06:228")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:228") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:228") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_229():
    result = parse("DQB1*06:229")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:229") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:229") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_22_01():
    result = parse("DQB1*06:22:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:22:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:22:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_22_02():
    result = parse("DQB1*06:22:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:22:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:22:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_22_03():
    result = parse("DQB1*06:22:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:22:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:22:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_23():
    result = parse("DQB1*06:23")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_230():
    result = parse("DQB1*06:230")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:230") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:230") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_231():
    result = parse("DQB1*06:231")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:231") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:231") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_232():
    result = parse("DQB1*06:232")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:232") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:232") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_233():
    result = parse("DQB1*06:233")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:233") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:233") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_234():
    result = parse("DQB1*06:234")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:234") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:234") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_235():
    result = parse("DQB1*06:235")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:235") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:235") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_236():
    result = parse("DQB1*06:236")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:236") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:236") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_237():
    result = parse("DQB1*06:237")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:237") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:237") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_238():
    result = parse("DQB1*06:238")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:238") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:238") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_239():
    result = parse("DQB1*06:239")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:239") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:239") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_24():
    result = parse("DQB1*06:24")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_240():
    result = parse("DQB1*06:240")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:240") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:240") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_241():
    result = parse("DQB1*06:241")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:241") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:241") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_242():
    result = parse("DQB1*06:242")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:242") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:242") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_243():
    result = parse("DQB1*06:243")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:243") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:243") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_244():
    result = parse("DQB1*06:244")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:244") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:244") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_245():
    result = parse("DQB1*06:245")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:245") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:245") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_246():
    result = parse("DQB1*06:246")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:246") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:246") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_247():
    result = parse("DQB1*06:247")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:247") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:247") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_248():
    result = parse("DQB1*06:248")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:248") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:248") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_249():
    result = parse("DQB1*06:249")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:249") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:249") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_25():
    result = parse("DQB1*06:25")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:25") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:25") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_250():
    result = parse("DQB1*06:250")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:250") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:250") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_251():
    result = parse("DQB1*06:251")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:251") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:251") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_252N():
    result = parse("DQB1*06:252N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:252N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:252N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_253():
    result = parse("DQB1*06:253")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:253") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:253") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_254():
    result = parse("DQB1*06:254")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:254") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:254") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_255():
    result = parse("DQB1*06:255")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:255") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:255") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_256():
    result = parse("DQB1*06:256")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:256") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:256") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_257():
    result = parse("DQB1*06:257")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:257") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:257") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_258():
    result = parse("DQB1*06:258")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:258") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:258") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_259():
    result = parse("DQB1*06:259")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:259") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:259") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_260():
    result = parse("DQB1*06:260")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:260") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:260") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_261():
    result = parse("DQB1*06:261")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:261") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:261") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_262():
    result = parse("DQB1*06:262")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:262") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:262") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_263():
    result = parse("DQB1*06:263")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:263") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:263") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_264():
    result = parse("DQB1*06:264")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:264") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:264") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_265():
    result = parse("DQB1*06:265")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:265") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:265") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_266():
    result = parse("DQB1*06:266")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:266") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:266") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_267():
    result = parse("DQB1*06:267")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:267") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:267") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_268():
    result = parse("DQB1*06:268")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:268") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:268") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_269():
    result = parse("DQB1*06:269")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:269") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:269") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_26N():
    result = parse("DQB1*06:26N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:26N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:26N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_270_01():
    result = parse("DQB1*06:270:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:270:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:270:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_270_02():
    result = parse("DQB1*06:270:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:270:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:270:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_271():
    result = parse("DQB1*06:271")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:271") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:271") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_272():
    result = parse("DQB1*06:272")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:272") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:272") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_273():
    result = parse("DQB1*06:273")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:273") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:273") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_274():
    result = parse("DQB1*06:274")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:274") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:274") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_275():
    result = parse("DQB1*06:275")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:275") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:275") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_276():
    result = parse("DQB1*06:276")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:276") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:276") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_277():
    result = parse("DQB1*06:277")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:277") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:277") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_278():
    result = parse("DQB1*06:278")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:278") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:278") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_279():
    result = parse("DQB1*06:279")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:279") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:279") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_27_01():
    result = parse("DQB1*06:27:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:27:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:27:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_27_02():
    result = parse("DQB1*06:27:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:27:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:27:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_28():
    result = parse("DQB1*06:28")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_280():
    result = parse("DQB1*06:280")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:280") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:280") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_281():
    result = parse("DQB1*06:281")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:281") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:281") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_282():
    result = parse("DQB1*06:282")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:282") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:282") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_283():
    result = parse("DQB1*06:283")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:283") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:283") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_284():
    result = parse("DQB1*06:284")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:284") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:284") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_285():
    result = parse("DQB1*06:285")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:285") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:285") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_286():
    result = parse("DQB1*06:286")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:286") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:286") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_287():
    result = parse("DQB1*06:287")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:287") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:287") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_288():
    result = parse("DQB1*06:288")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:288") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:288") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_289():
    result = parse("DQB1*06:289")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:289") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:289") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_29():
    result = parse("DQB1*06:29")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_290():
    result = parse("DQB1*06:290")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:290") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:290") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_291():
    result = parse("DQB1*06:291")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:291") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:291") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_292():
    result = parse("DQB1*06:292")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:292") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:292") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_293():
    result = parse("DQB1*06:293")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:293") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:293") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_294():
    result = parse("DQB1*06:294")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:294") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:294") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_295():
    result = parse("DQB1*06:295")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:295") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:295") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_296():
    result = parse("DQB1*06:296")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:296") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:296") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_297():
    result = parse("DQB1*06:297")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:297") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:297") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_298():
    result = parse("DQB1*06:298")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:298") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:298") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_299():
    result = parse("DQB1*06:299")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:299") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:299") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_30():
    result = parse("DQB1*06:30")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_300():
    result = parse("DQB1*06:300")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:300") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:300") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_301():
    result = parse("DQB1*06:301")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:301") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:301") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_302():
    result = parse("DQB1*06:302")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:302") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:302") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_303N():
    result = parse("DQB1*06:303N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:303N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:303N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_304N():
    result = parse("DQB1*06:304N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:304N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:304N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_305():
    result = parse("DQB1*06:305")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:305") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:305") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_306N():
    result = parse("DQB1*06:306N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:306N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:306N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_307():
    result = parse("DQB1*06:307")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:307") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:307") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_308N():
    result = parse("DQB1*06:308N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:308N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:308N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_309():
    result = parse("DQB1*06:309")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:309") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:309") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_31():
    result = parse("DQB1*06:31")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_310():
    result = parse("DQB1*06:310")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:310") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:310") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_311():
    result = parse("DQB1*06:311")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:311") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:311") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_312():
    result = parse("DQB1*06:312")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:312") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:312") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_313():
    result = parse("DQB1*06:313")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:313") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:313") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_314():
    result = parse("DQB1*06:314")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:314") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:314") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_315():
    result = parse("DQB1*06:315")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:315") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:315") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_316():
    result = parse("DQB1*06:316")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:316") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:316") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_317N():
    result = parse("DQB1*06:317N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:317N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:317N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_318():
    result = parse("DQB1*06:318")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:318") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:318") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_319():
    result = parse("DQB1*06:319")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:319") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:319") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_320():
    result = parse("DQB1*06:320")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:320") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:320") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_321():
    result = parse("DQB1*06:321")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:321") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:321") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_322():
    result = parse("DQB1*06:322")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:322") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:322") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_323():
    result = parse("DQB1*06:323")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:323") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:323") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_324():
    result = parse("DQB1*06:324")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:324") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:324") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_325():
    result = parse("DQB1*06:325")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:325") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:325") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_326():
    result = parse("DQB1*06:326")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:326") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:326") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_327():
    result = parse("DQB1*06:327")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:327") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:327") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_328():
    result = parse("DQB1*06:328")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:328") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:328") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_329():
    result = parse("DQB1*06:329")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:329") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:329") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_32_01():
    result = parse("DQB1*06:32:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:32:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:32:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_32_02():
    result = parse("DQB1*06:32:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:32:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:32:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_33():
    result = parse("DQB1*06:33")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_330N():
    result = parse("DQB1*06:330N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:330N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:330N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_331():
    result = parse("DQB1*06:331")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:331") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:331") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_332():
    result = parse("DQB1*06:332")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:332") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:332") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_333():
    result = parse("DQB1*06:333")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:333") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:333") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_334():
    result = parse("DQB1*06:334")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:334") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:334") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_335():
    result = parse("DQB1*06:335")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:335") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:335") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_336():
    result = parse("DQB1*06:336")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:336") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:336") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_337():
    result = parse("DQB1*06:337")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:337") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:337") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_338():
    result = parse("DQB1*06:338")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:338") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:338") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_339():
    result = parse("DQB1*06:339")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:339") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:339") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_34():
    result = parse("DQB1*06:34")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_340():
    result = parse("DQB1*06:340")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:340") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:340") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_341N():
    result = parse("DQB1*06:341N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:341N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:341N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_342():
    result = parse("DQB1*06:342")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:342") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:342") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_343():
    result = parse("DQB1*06:343")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:343") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:343") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_344():
    result = parse("DQB1*06:344")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:344") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:344") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_345N():
    result = parse("DQB1*06:345N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:345N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:345N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_346():
    result = parse("DQB1*06:346")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:346") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:346") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_347():
    result = parse("DQB1*06:347")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:347") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:347") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_348():
    result = parse("DQB1*06:348")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:348") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:348") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_349():
    result = parse("DQB1*06:349")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:349") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:349") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_35():
    result = parse("DQB1*06:35")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_350():
    result = parse("DQB1*06:350")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:350") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:350") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_351():
    result = parse("DQB1*06:351")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:351") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:351") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_352():
    result = parse("DQB1*06:352")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:352") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:352") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_353():
    result = parse("DQB1*06:353")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:353") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:353") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_354():
    result = parse("DQB1*06:354")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:354") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:354") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_355():
    result = parse("DQB1*06:355")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:355") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:355") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_356():
    result = parse("DQB1*06:356")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:356") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:356") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_357():
    result = parse("DQB1*06:357")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:357") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:357") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_358():
    result = parse("DQB1*06:358")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:358") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:358") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_359():
    result = parse("DQB1*06:359")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:359") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:359") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_36():
    result = parse("DQB1*06:36")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_360():
    result = parse("DQB1*06:360")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:360") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:360") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_361():
    result = parse("DQB1*06:361")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:361") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:361") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_362():
    result = parse("DQB1*06:362")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:362") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:362") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_363():
    result = parse("DQB1*06:363")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:363") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:363") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_364():
    result = parse("DQB1*06:364")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:364") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:364") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_365():
    result = parse("DQB1*06:365")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:365") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:365") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_366():
    result = parse("DQB1*06:366")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:366") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:366") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_367():
    result = parse("DQB1*06:367")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:367") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:367") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_368():
    result = parse("DQB1*06:368")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:368") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:368") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_369():
    result = parse("DQB1*06:369")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:369") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:369") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_37():
    result = parse("DQB1*06:37")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_370():
    result = parse("DQB1*06:370")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:370") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:370") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_371():
    result = parse("DQB1*06:371")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:371") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:371") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_372():
    result = parse("DQB1*06:372")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:372") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:372") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_373():
    result = parse("DQB1*06:373")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:373") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:373") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_374():
    result = parse("DQB1*06:374")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:374") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:374") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_38():
    result = parse("DQB1*06:38")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_39():
    result = parse("DQB1*06:39")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_40():
    result = parse("DQB1*06:40")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:40") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:40") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_41():
    result = parse("DQB1*06:41")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:41") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:41") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_42():
    result = parse("DQB1*06:42")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_43():
    result = parse("DQB1*06:43")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_44():
    result = parse("DQB1*06:44")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_45():
    result = parse("DQB1*06:45")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_46():
    result = parse("DQB1*06:46")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_47():
    result = parse("DQB1*06:47")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_48_01():
    result = parse("DQB1*06:48:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:48:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:48:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_48_02():
    result = parse("DQB1*06:48:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:48:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:48:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_49():
    result = parse("DQB1*06:49")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_50():
    result = parse("DQB1*06:50")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_51_01():
    result = parse("DQB1*06:51:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:51:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:51:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_51_02():
    result = parse("DQB1*06:51:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:51:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:51:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_52():
    result = parse("DQB1*06:52")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_53_01():
    result = parse("DQB1*06:53:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:53:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:53:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_53_02():
    result = parse("DQB1*06:53:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:53:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:53:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_54N():
    result = parse("DQB1*06:54N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:54N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:54N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_55():
    result = parse("DQB1*06:55")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:55") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:55") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_56():
    result = parse("DQB1*06:56")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_57_01():
    result = parse("DQB1*06:57:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:57:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:57:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_57_02():
    result = parse("DQB1*06:57:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:57:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:57:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_58():
    result = parse("DQB1*06:58")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_59():
    result = parse("DQB1*06:59")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_60():
    result = parse("DQB1*06:60")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_61():
    result = parse("DQB1*06:61")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_62():
    result = parse("DQB1*06:62")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_63():
    result = parse("DQB1*06:63")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_64():
    result = parse("DQB1*06:64")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_65():
    result = parse("DQB1*06:65")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_66():
    result = parse("DQB1*06:66")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_67():
    result = parse("DQB1*06:67")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_68():
    result = parse("DQB1*06:68")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:68") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:68") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_69_01():
    result = parse("DQB1*06:69:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:69:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:69:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_69_02():
    result = parse("DQB1*06:69:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:69:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:69:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_70():
    result = parse("DQB1*06:70")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_71():
    result = parse("DQB1*06:71")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_72():
    result = parse("DQB1*06:72")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:72") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:72") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_73():
    result = parse("DQB1*06:73")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_74():
    result = parse("DQB1*06:74")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_75N():
    result = parse("DQB1*06:75N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:75N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:75N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_76():
    result = parse("DQB1*06:76")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_77N():
    result = parse("DQB1*06:77N")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:77N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:77N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_78():
    result = parse("DQB1*06:78")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_79_01():
    result = parse("DQB1*06:79:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:79:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:79:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_79_02():
    result = parse("DQB1*06:79:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:79:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:79:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_80():
    result = parse("DQB1*06:80")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_81():
    result = parse("DQB1*06:81")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_82():
    result = parse("DQB1*06:82")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_83():
    result = parse("DQB1*06:83")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_84():
    result = parse("DQB1*06:84")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_85():
    result = parse("DQB1*06:85")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_86():
    result = parse("DQB1*06:86")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_87():
    result = parse("DQB1*06:87")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_88():
    result = parse("DQB1*06:88")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_89():
    result = parse("DQB1*06:89")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_90():
    result = parse("DQB1*06:90")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_91():
    result = parse("DQB1*06:91")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:91") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:91") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_92_01():
    result = parse("DQB1*06:92:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:92:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:92:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_92_02():
    result = parse("DQB1*06:92:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:92:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:92:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_93():
    result = parse("DQB1*06:93")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_94():
    result = parse("DQB1*06:94")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_95():
    result = parse("DQB1*06:95")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_96_01():
    result = parse("DQB1*06:96:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:96:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:96:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_96_02():
    result = parse("DQB1*06:96:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:96:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:96:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_97():
    result = parse("DQB1*06:97")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_98():
    result = parse("DQB1*06:98")
    assert result.__class__ is Allele, f'Expected parse("DQB1*06:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("DQB1*06:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_99_01():
    result = parse("DQB1*06:99:01")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:99:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:99:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_99_02():
    result = parse("DQB1*06:99:02")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:99:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:99:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_DQB1_06_99_03():
    result = parse("DQB1*06:99:03")
    assert result.__class__ is Allele, (
        f'Expected parse("DQB1*06:99:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("DQB1*06:99:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_01():
    result = parse("E*01:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_02():
    result = parse("E*01:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_03():
    result = parse("E*01:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_04():
    result = parse("E*01:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_05():
    result = parse("E*01:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_06():
    result = parse("E*01:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_07():
    result = parse("E*01:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_08():
    result = parse("E*01:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_09():
    result = parse("E*01:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_10():
    result = parse("E*01:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_11():
    result = parse("E*01:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_12():
    result = parse("E*01:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_13():
    result = parse("E*01:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_14():
    result = parse("E*01:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_15():
    result = parse("E*01:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_16():
    result = parse("E*01:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_17():
    result = parse("E*01:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_18():
    result = parse("E*01:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_19():
    result = parse("E*01:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_20():
    result = parse("E*01:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_21():
    result = parse("E*01:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_22():
    result = parse("E*01:01:01:22")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:22") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:22") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_23():
    result = parse("E*01:01:01:23")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:23") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:23") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_24():
    result = parse("E*01:01:01:24")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:24") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:24") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_25():
    result = parse("E*01:01:01:25")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:25") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:25") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_26():
    result = parse("E*01:01:01:26")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:26") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:26") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_27():
    result = parse("E*01:01:01:27")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:27") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:27") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_28():
    result = parse("E*01:01:01:28")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:28") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:28") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_29():
    result = parse("E*01:01:01:29")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:29") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:29") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_01_30():
    result = parse("E*01:01:01:30")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:01:30") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:01:30") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_02():
    result = parse("E*01:01:02")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_03():
    result = parse("E*01:01:03")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_04():
    result = parse("E*01:01:04")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_05():
    result = parse("E*01:01:05")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_06():
    result = parse("E*01:01:06")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_07():
    result = parse("E*01:01:07")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_08():
    result = parse("E*01:01:08")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_09():
    result = parse("E*01:01:09")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_10():
    result = parse("E*01:01:10")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_11():
    result = parse("E*01:01:11")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_12():
    result = parse("E*01:01:12")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_13():
    result = parse("E*01:01:13")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_14():
    result = parse("E*01:01:14")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_15():
    result = parse("E*01:01:15")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_16():
    result = parse("E*01:01:16")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_17():
    result = parse("E*01:01:17")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_18_01():
    result = parse("E*01:01:18:01")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:18:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:18:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_18_02():
    result = parse("E*01:01:18:02")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:01:18:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:01:18:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_19():
    result = parse("E*01:01:19")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_20():
    result = parse("E*01:01:20")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_21():
    result = parse("E*01:01:21")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_22():
    result = parse("E*01:01:22")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_23():
    result = parse("E*01:01:23")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_24():
    result = parse("E*01:01:24")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_25():
    result = parse("E*01:01:25")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_26():
    result = parse("E*01:01:26")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_27():
    result = parse("E*01:01:27")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_28():
    result = parse("E*01:01:28")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_29():
    result = parse("E*01:01:29")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_30():
    result = parse("E*01:01:30")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_31():
    result = parse("E*01:01:31")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_32():
    result = parse("E*01:01:32")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_33():
    result = parse("E*01:01:33")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_01_34():
    result = parse("E*01:01:34")
    assert result.__class__ is Allele, f'Expected parse("E*01:01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:01:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_01_01():
    result = parse("E*01:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_01_02():
    result = parse("E*01:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_01_03():
    result = parse("E*01:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_01_04():
    result = parse("E*01:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_01_05():
    result = parse("E*01:03:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_01_06():
    result = parse("E*01:03:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_01_07():
    result = parse("E*01:03:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_01_08():
    result = parse("E*01:03:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_01_09():
    result = parse("E*01:03:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_01_10():
    result = parse("E*01:03:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_01_11():
    result = parse("E*01:03:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_01():
    result = parse("E*01:03:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_02():
    result = parse("E*01:03:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_03():
    result = parse("E*01:03:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_04():
    result = parse("E*01:03:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_05():
    result = parse("E*01:03:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_06():
    result = parse("E*01:03:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_07():
    result = parse("E*01:03:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_08():
    result = parse("E*01:03:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_09():
    result = parse("E*01:03:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_10():
    result = parse("E*01:03:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_11():
    result = parse("E*01:03:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_12():
    result = parse("E*01:03:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_13():
    result = parse("E*01:03:02:13")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_14():
    result = parse("E*01:03:02:14")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_15():
    result = parse("E*01:03:02:15")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_16():
    result = parse("E*01:03:02:16")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_17():
    result = parse("E*01:03:02:17")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_02_18():
    result = parse("E*01:03:02:18")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:02:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:02:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_03():
    result = parse("E*01:03:03")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_04():
    result = parse("E*01:03:04")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_05_01():
    result = parse("E*01:03:05:01")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:05:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:05:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_05_02():
    result = parse("E*01:03:05:02")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:03:05:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:03:05:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_06():
    result = parse("E*01:03:06")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_07():
    result = parse("E*01:03:07")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_08():
    result = parse("E*01:03:08")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_09():
    result = parse("E*01:03:09")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_10():
    result = parse("E*01:03:10")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:10") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_11():
    result = parse("E*01:03:11")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_12():
    result = parse("E*01:03:12")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_13():
    result = parse("E*01:03:13")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_14():
    result = parse("E*01:03:14")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_15():
    result = parse("E*01:03:15")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_16():
    result = parse("E*01:03:16")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_17():
    result = parse("E*01:03:17")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_18():
    result = parse("E*01:03:18")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_19():
    result = parse("E*01:03:19")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_20():
    result = parse("E*01:03:20")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_21():
    result = parse("E*01:03:21")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_22():
    result = parse("E*01:03:22")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:22") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:22") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_23():
    result = parse("E*01:03:23")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_24():
    result = parse("E*01:03:24")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_25():
    result = parse("E*01:03:25")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_26():
    result = parse("E*01:03:26")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:26") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:26") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_27():
    result = parse("E*01:03:27")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:27") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:27") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_28():
    result = parse("E*01:03:28")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:28") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:28") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_29():
    result = parse("E*01:03:29")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:29") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:29") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_30():
    result = parse("E*01:03:30")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:30") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:30") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_31():
    result = parse("E*01:03:31")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:31") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:31") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_32():
    result = parse("E*01:03:32")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:32") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:32") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_33():
    result = parse("E*01:03:33")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:33") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:33") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_34():
    result = parse("E*01:03:34")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:34") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:34") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_03_35():
    result = parse("E*01:03:35")
    assert result.__class__ is Allele, f'Expected parse("E*01:03:35") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:03:35") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_04():
    result = parse("E*01:04")
    assert result.__class__ is Allele, f'Expected parse("E*01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_05_01():
    result = parse("E*01:05:01")
    assert result.__class__ is Allele, f'Expected parse("E*01:05:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:05:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_05_02():
    result = parse("E*01:05:02")
    assert result.__class__ is Allele, f'Expected parse("E*01:05:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:05:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_06_01():
    result = parse("E*01:06:01")
    assert result.__class__ is Allele, f'Expected parse("E*01:06:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_06_02():
    result = parse("E*01:06:02")
    assert result.__class__ is Allele, f'Expected parse("E*01:06:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_06_03():
    result = parse("E*01:06:03")
    assert result.__class__ is Allele, f'Expected parse("E*01:06:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:06:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_06_04():
    result = parse("E*01:06:04")
    assert result.__class__ is Allele, f'Expected parse("E*01:06:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:06:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_06_05():
    result = parse("E*01:06:05")
    assert result.__class__ is Allele, f'Expected parse("E*01:06:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:06:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_06_06():
    result = parse("E*01:06:06")
    assert result.__class__ is Allele, f'Expected parse("E*01:06:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:06:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_07():
    result = parse("E*01:07")
    assert result.__class__ is Allele, f'Expected parse("E*01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_08_01N():
    result = parse("E*01:08:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:08:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:08:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_08_02N():
    result = parse("E*01:08:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:08:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:08:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_09():
    result = parse("E*01:09")
    assert result.__class__ is Allele, f'Expected parse("E*01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_100():
    result = parse("E*01:100")
    assert result.__class__ is Allele, f'Expected parse("E*01:100") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:100") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_101():
    result = parse("E*01:101")
    assert result.__class__ is Allele, f'Expected parse("E*01:101") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:101") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_102():
    result = parse("E*01:102")
    assert result.__class__ is Allele, f'Expected parse("E*01:102") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:102") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_103():
    result = parse("E*01:103")
    assert result.__class__ is Allele, f'Expected parse("E*01:103") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:103") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_104():
    result = parse("E*01:104")
    assert result.__class__ is Allele, f'Expected parse("E*01:104") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:104") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_105():
    result = parse("E*01:105")
    assert result.__class__ is Allele, f'Expected parse("E*01:105") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:105") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_106():
    result = parse("E*01:106")
    assert result.__class__ is Allele, f'Expected parse("E*01:106") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:106") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_107():
    result = parse("E*01:107")
    assert result.__class__ is Allele, f'Expected parse("E*01:107") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:107") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_108():
    result = parse("E*01:108")
    assert result.__class__ is Allele, f'Expected parse("E*01:108") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:108") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_109():
    result = parse("E*01:109")
    assert result.__class__ is Allele, f'Expected parse("E*01:109") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:109") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_10_01_01():
    result = parse("E*01:10:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:10:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:10:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_10_01_02():
    result = parse("E*01:10:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:10:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:10:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_11():
    result = parse("E*01:11")
    assert result.__class__ is Allele, f'Expected parse("E*01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_110():
    result = parse("E*01:110")
    assert result.__class__ is Allele, f'Expected parse("E*01:110") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:110") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_111():
    result = parse("E*01:111")
    assert result.__class__ is Allele, f'Expected parse("E*01:111") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:111") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_112():
    result = parse("E*01:112")
    assert result.__class__ is Allele, f'Expected parse("E*01:112") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:112") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_113():
    result = parse("E*01:113")
    assert result.__class__ is Allele, f'Expected parse("E*01:113") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:113") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_114():
    result = parse("E*01:114")
    assert result.__class__ is Allele, f'Expected parse("E*01:114") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:114") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_115():
    result = parse("E*01:115")
    assert result.__class__ is Allele, f'Expected parse("E*01:115") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:115") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_12_01_01():
    result = parse("E*01:12:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:12:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:12:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_12_01_02():
    result = parse("E*01:12:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:12:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:12:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_13():
    result = parse("E*01:13")
    assert result.__class__ is Allele, f'Expected parse("E*01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_14():
    result = parse("E*01:14")
    assert result.__class__ is Allele, f'Expected parse("E*01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_15():
    result = parse("E*01:15")
    assert result.__class__ is Allele, f'Expected parse("E*01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_16_01():
    result = parse("E*01:16:01")
    assert result.__class__ is Allele, f'Expected parse("E*01:16:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:16:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_16_02():
    result = parse("E*01:16:02")
    assert result.__class__ is Allele, f'Expected parse("E*01:16:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:16:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_17():
    result = parse("E*01:17")
    assert result.__class__ is Allele, f'Expected parse("E*01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_18():
    result = parse("E*01:18")
    assert result.__class__ is Allele, f'Expected parse("E*01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_19():
    result = parse("E*01:19")
    assert result.__class__ is Allele, f'Expected parse("E*01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_20():
    result = parse("E*01:20")
    assert result.__class__ is Allele, f'Expected parse("E*01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_21_01N():
    result = parse("E*01:21:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:21:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:21:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_21_02N():
    result = parse("E*01:21:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:21:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:21:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_22():
    result = parse("E*01:22")
    assert result.__class__ is Allele, f'Expected parse("E*01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_23():
    result = parse("E*01:23")
    assert result.__class__ is Allele, f'Expected parse("E*01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_24():
    result = parse("E*01:24")
    assert result.__class__ is Allele, f'Expected parse("E*01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_25N():
    result = parse("E*01:25N")
    assert result.__class__ is Allele, f'Expected parse("E*01:25N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:25N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_26():
    result = parse("E*01:26")
    assert result.__class__ is Allele, f'Expected parse("E*01:26") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:26") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_27():
    result = parse("E*01:27")
    assert result.__class__ is Allele, f'Expected parse("E*01:27") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:27") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_28():
    result = parse("E*01:28")
    assert result.__class__ is Allele, f'Expected parse("E*01:28") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:28") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_29():
    result = parse("E*01:29")
    assert result.__class__ is Allele, f'Expected parse("E*01:29") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:29") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_30():
    result = parse("E*01:30")
    assert result.__class__ is Allele, f'Expected parse("E*01:30") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:30") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_31():
    result = parse("E*01:31")
    assert result.__class__ is Allele, f'Expected parse("E*01:31") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:31") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_32_01():
    result = parse("E*01:32:01")
    assert result.__class__ is Allele, f'Expected parse("E*01:32:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:32:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_32_02():
    result = parse("E*01:32:02")
    assert result.__class__ is Allele, f'Expected parse("E*01:32:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:32:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_33():
    result = parse("E*01:33")
    assert result.__class__ is Allele, f'Expected parse("E*01:33") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:33") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_34():
    result = parse("E*01:34")
    assert result.__class__ is Allele, f'Expected parse("E*01:34") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:34") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_35():
    result = parse("E*01:35")
    assert result.__class__ is Allele, f'Expected parse("E*01:35") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:35") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_36():
    result = parse("E*01:36")
    assert result.__class__ is Allele, f'Expected parse("E*01:36") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:36") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_37():
    result = parse("E*01:37")
    assert result.__class__ is Allele, f'Expected parse("E*01:37") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:37") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_38():
    result = parse("E*01:38")
    assert result.__class__ is Allele, f'Expected parse("E*01:38") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:38") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_39():
    result = parse("E*01:39")
    assert result.__class__ is Allele, f'Expected parse("E*01:39") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:39") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_40_01():
    result = parse("E*01:40:01")
    assert result.__class__ is Allele, f'Expected parse("E*01:40:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:40:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_40_02():
    result = parse("E*01:40:02")
    assert result.__class__ is Allele, f'Expected parse("E*01:40:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:40:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_41_01_01():
    result = parse("E*01:41:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:41:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:41:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_41_01_02():
    result = parse("E*01:41:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:41:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:41:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_42():
    result = parse("E*01:42")
    assert result.__class__ is Allele, f'Expected parse("E*01:42") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:42") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_43():
    result = parse("E*01:43")
    assert result.__class__ is Allele, f'Expected parse("E*01:43") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:43") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_44():
    result = parse("E*01:44")
    assert result.__class__ is Allele, f'Expected parse("E*01:44") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:44") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_45():
    result = parse("E*01:45")
    assert result.__class__ is Allele, f'Expected parse("E*01:45") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:45") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_46():
    result = parse("E*01:46")
    assert result.__class__ is Allele, f'Expected parse("E*01:46") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:46") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_47():
    result = parse("E*01:47")
    assert result.__class__ is Allele, f'Expected parse("E*01:47") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:47") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_48():
    result = parse("E*01:48")
    assert result.__class__ is Allele, f'Expected parse("E*01:48") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:48") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_49():
    result = parse("E*01:49")
    assert result.__class__ is Allele, f'Expected parse("E*01:49") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:49") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_50():
    result = parse("E*01:50")
    assert result.__class__ is Allele, f'Expected parse("E*01:50") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:50") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_51():
    result = parse("E*01:51")
    assert result.__class__ is Allele, f'Expected parse("E*01:51") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:51") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_52():
    result = parse("E*01:52")
    assert result.__class__ is Allele, f'Expected parse("E*01:52") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:52") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_53():
    result = parse("E*01:53")
    assert result.__class__ is Allele, f'Expected parse("E*01:53") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:53") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_54_01():
    result = parse("E*01:54:01")
    assert result.__class__ is Allele, f'Expected parse("E*01:54:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:54:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_54_02():
    result = parse("E*01:54:02")
    assert result.__class__ is Allele, f'Expected parse("E*01:54:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("E*01:54:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_55N():
    result = parse("E*01:55N")
    assert result.__class__ is Allele, f'Expected parse("E*01:55N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:55N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_56():
    result = parse("E*01:56")
    assert result.__class__ is Allele, f'Expected parse("E*01:56") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:56") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_57():
    result = parse("E*01:57")
    assert result.__class__ is Allele, f'Expected parse("E*01:57") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:57") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_58():
    result = parse("E*01:58")
    assert result.__class__ is Allele, f'Expected parse("E*01:58") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:58") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_59():
    result = parse("E*01:59")
    assert result.__class__ is Allele, f'Expected parse("E*01:59") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:59") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_60():
    result = parse("E*01:60")
    assert result.__class__ is Allele, f'Expected parse("E*01:60") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:60") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_61():
    result = parse("E*01:61")
    assert result.__class__ is Allele, f'Expected parse("E*01:61") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:61") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_62():
    result = parse("E*01:62")
    assert result.__class__ is Allele, f'Expected parse("E*01:62") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:62") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_63():
    result = parse("E*01:63")
    assert result.__class__ is Allele, f'Expected parse("E*01:63") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:63") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_64():
    result = parse("E*01:64")
    assert result.__class__ is Allele, f'Expected parse("E*01:64") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:64") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_65():
    result = parse("E*01:65")
    assert result.__class__ is Allele, f'Expected parse("E*01:65") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:65") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_66():
    result = parse("E*01:66")
    assert result.__class__ is Allele, f'Expected parse("E*01:66") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:66") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_67():
    result = parse("E*01:67")
    assert result.__class__ is Allele, f'Expected parse("E*01:67") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:67") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_68Q():
    result = parse("E*01:68Q")
    assert result.__class__ is Allele, f'Expected parse("E*01:68Q") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:68Q") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_69():
    result = parse("E*01:69")
    assert result.__class__ is Allele, f'Expected parse("E*01:69") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:69") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_70():
    result = parse("E*01:70")
    assert result.__class__ is Allele, f'Expected parse("E*01:70") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:70") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_71():
    result = parse("E*01:71")
    assert result.__class__ is Allele, f'Expected parse("E*01:71") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:71") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_72_01_01():
    result = parse("E*01:72:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:72:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:72:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_72_01_02():
    result = parse("E*01:72:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("E*01:72:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("E*01:72:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_73():
    result = parse("E*01:73")
    assert result.__class__ is Allele, f'Expected parse("E*01:73") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:73") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_74():
    result = parse("E*01:74")
    assert result.__class__ is Allele, f'Expected parse("E*01:74") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:74") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_75():
    result = parse("E*01:75")
    assert result.__class__ is Allele, f'Expected parse("E*01:75") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:75") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_76():
    result = parse("E*01:76")
    assert result.__class__ is Allele, f'Expected parse("E*01:76") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:76") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_77():
    result = parse("E*01:77")
    assert result.__class__ is Allele, f'Expected parse("E*01:77") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:77") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_78():
    result = parse("E*01:78")
    assert result.__class__ is Allele, f'Expected parse("E*01:78") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:78") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_79():
    result = parse("E*01:79")
    assert result.__class__ is Allele, f'Expected parse("E*01:79") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:79") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_80():
    result = parse("E*01:80")
    assert result.__class__ is Allele, f'Expected parse("E*01:80") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:80") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_81():
    result = parse("E*01:81")
    assert result.__class__ is Allele, f'Expected parse("E*01:81") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:81") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_82():
    result = parse("E*01:82")
    assert result.__class__ is Allele, f'Expected parse("E*01:82") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:82") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_83():
    result = parse("E*01:83")
    assert result.__class__ is Allele, f'Expected parse("E*01:83") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:83") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_84():
    result = parse("E*01:84")
    assert result.__class__ is Allele, f'Expected parse("E*01:84") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:84") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_85():
    result = parse("E*01:85")
    assert result.__class__ is Allele, f'Expected parse("E*01:85") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:85") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_86():
    result = parse("E*01:86")
    assert result.__class__ is Allele, f'Expected parse("E*01:86") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:86") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_87():
    result = parse("E*01:87")
    assert result.__class__ is Allele, f'Expected parse("E*01:87") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:87") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_88():
    result = parse("E*01:88")
    assert result.__class__ is Allele, f'Expected parse("E*01:88") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:88") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_89():
    result = parse("E*01:89")
    assert result.__class__ is Allele, f'Expected parse("E*01:89") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:89") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_90():
    result = parse("E*01:90")
    assert result.__class__ is Allele, f'Expected parse("E*01:90") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:90") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_91N():
    result = parse("E*01:91N")
    assert result.__class__ is Allele, f'Expected parse("E*01:91N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:91N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_92():
    result = parse("E*01:92")
    assert result.__class__ is Allele, f'Expected parse("E*01:92") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:92") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_93():
    result = parse("E*01:93")
    assert result.__class__ is Allele, f'Expected parse("E*01:93") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:93") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_94():
    result = parse("E*01:94")
    assert result.__class__ is Allele, f'Expected parse("E*01:94") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:94") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_95():
    result = parse("E*01:95")
    assert result.__class__ is Allele, f'Expected parse("E*01:95") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:95") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_96():
    result = parse("E*01:96")
    assert result.__class__ is Allele, f'Expected parse("E*01:96") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:96") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_97():
    result = parse("E*01:97")
    assert result.__class__ is Allele, f'Expected parse("E*01:97") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:97") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_98():
    result = parse("E*01:98")
    assert result.__class__ is Allele, f'Expected parse("E*01:98") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:98") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_E_01_99():
    result = parse("E*01:99")
    assert result.__class__ is Allele, f'Expected parse("E*01:99") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("E*01:99") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_01():
    result = parse("F*01:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_02():
    result = parse("F*01:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_03():
    result = parse("F*01:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_04():
    result = parse("F*01:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_05():
    result = parse("F*01:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_06():
    result = parse("F*01:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_07():
    result = parse("F*01:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_08():
    result = parse("F*01:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_09():
    result = parse("F*01:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_10():
    result = parse("F*01:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_11():
    result = parse("F*01:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_12():
    result = parse("F*01:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_13():
    result = parse("F*01:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_14():
    result = parse("F*01:01:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:14") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_15():
    result = parse("F*01:01:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:15") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_16():
    result = parse("F*01:01:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:16") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_17():
    result = parse("F*01:01:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:17") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_18():
    result = parse("F*01:01:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:18") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_19():
    result = parse("F*01:01:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:19") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_20():
    result = parse("F*01:01:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:20") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_01_21():
    result = parse("F*01:01:01:21")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:01:21") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:01:21") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_02_01():
    result = parse("F*01:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_02_02():
    result = parse("F*01:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_02_03():
    result = parse("F*01:01:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_02_04():
    result = parse("F*01:01:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_02_05():
    result = parse("F*01:01:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:02:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_02_06():
    result = parse("F*01:01:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:02:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_02_07():
    result = parse("F*01:01:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:02:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_02_08():
    result = parse("F*01:01:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:02:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_02_09():
    result = parse("F*01:01:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:02:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_02_10():
    result = parse("F*01:01:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:02:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_02_11():
    result = parse("F*01:01:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:02:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_02_12():
    result = parse("F*01:01:02:12")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:01:02:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:01:02:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_04():
    result = parse("F*01:01:04")
    assert result.__class__ is Allele, f'Expected parse("F*01:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("F*01:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_01_05():
    result = parse("F*01:01:05")
    assert result.__class__ is Allele, f'Expected parse("F*01:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("F*01:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_02():
    result = parse("F*01:02")
    assert result.__class__ is Allele, f'Expected parse("F*01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("F*01:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_03_01_01():
    result = parse("F*01:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_03_01_02():
    result = parse("F*01:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_03_01_03():
    result = parse("F*01:03:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:03:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:03:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_03_01_04():
    result = parse("F*01:03:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:03:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:03:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_04_01_01():
    result = parse("F*01:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_04_01_02():
    result = parse("F*01:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("F*01:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("F*01:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_05():
    result = parse("F*01:05")
    assert result.__class__ is Allele, f'Expected parse("F*01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("F*01:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_F_01_06():
    result = parse("F*01:06")
    assert result.__class__ is Allele, f'Expected parse("F*01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("F*01:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_01_01():
    result = parse("G*01:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_01_02():
    result = parse("G*01:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_01_03():
    result = parse("G*01:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_01_04():
    result = parse("G*01:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_01_05():
    result = parse("G*01:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_01_06():
    result = parse("G*01:01:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:01:06") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_01_07():
    result = parse("G*01:01:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:01:07") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_01_08():
    result = parse("G*01:01:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:01:08") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_01_09():
    result = parse("G*01:01:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:01:09") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_01_10():
    result = parse("G*01:01:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:01:10") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_01_11():
    result = parse("G*01:01:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:01:11") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_01_12():
    result = parse("G*01:01:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:01:12") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_01_13():
    result = parse("G*01:01:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:01:13") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_01_14Q():
    result = parse("G*01:01:01:14Q")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:01:14Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:01:14Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_02_01():
    result = parse("G*01:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_02_02():
    result = parse("G*01:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_02_03():
    result = parse("G*01:01:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_02_04():
    result = parse("G*01:01:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:02:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_03_01():
    result = parse("G*01:01:03:01")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:03:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:03:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_03_02():
    result = parse("G*01:01:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:03:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_03_03():
    result = parse("G*01:01:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:03:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_03_04():
    result = parse("G*01:01:03:04")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:03:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:03:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_04():
    result = parse("G*01:01:04")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_05():
    result = parse("G*01:01:05")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_06():
    result = parse("G*01:01:06")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_07():
    result = parse("G*01:01:07")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_08():
    result = parse("G*01:01:08")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:08") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_09():
    result = parse("G*01:01:09")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_11():
    result = parse("G*01:01:11")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_12():
    result = parse("G*01:01:12")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_13():
    result = parse("G*01:01:13")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:13") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_14():
    result = parse("G*01:01:14")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_15():
    result = parse("G*01:01:15")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_16():
    result = parse("G*01:01:16")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_17():
    result = parse("G*01:01:17")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_18():
    result = parse("G*01:01:18")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_19():
    result = parse("G*01:01:19")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_20():
    result = parse("G*01:01:20")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_21():
    result = parse("G*01:01:21")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:21") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:21") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_22_01():
    result = parse("G*01:01:22:01")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:22:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:22:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_22_02():
    result = parse("G*01:01:22:02")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:22:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:22:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_22_03():
    result = parse("G*01:01:22:03")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:01:22:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:01:22:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_23():
    result = parse("G*01:01:23")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:23") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_24():
    result = parse("G*01:01:24")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:24") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_01_25():
    result = parse("G*01:01:25")
    assert result.__class__ is Allele, f'Expected parse("G*01:01:25") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:01:25") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_02():
    result = parse("G*01:02")
    assert result.__class__ is Allele, f'Expected parse("G*01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_03_01_01():
    result = parse("G*01:03:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:03:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:03:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_03_01_02():
    result = parse("G*01:03:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:03:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:03:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_04_01_01():
    result = parse("G*01:04:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:04:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:04:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_04_01_02():
    result = parse("G*01:04:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:04:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:04:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_04_01_03():
    result = parse("G*01:04:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:04:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:04:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_04_01_04Q():
    result = parse("G*01:04:01:04Q")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:04:01:04Q") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:04:01:04Q") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_04_02():
    result = parse("G*01:04:02")
    assert result.__class__ is Allele, f'Expected parse("G*01:04:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_04_03():
    result = parse("G*01:04:03")
    assert result.__class__ is Allele, f'Expected parse("G*01:04:03") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_04_04():
    result = parse("G*01:04:04")
    assert result.__class__ is Allele, f'Expected parse("G*01:04:04") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:04:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_04_05():
    result = parse("G*01:04:05")
    assert result.__class__ is Allele, f'Expected parse("G*01:04:05") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:04:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_04_06():
    result = parse("G*01:04:06")
    assert result.__class__ is Allele, f'Expected parse("G*01:04:06") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:04:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_05N():
    result = parse("G*01:05N")
    assert result.__class__ is Allele, f'Expected parse("G*01:05N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:05N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_06_01_01():
    result = parse("G*01:06:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:06:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:06:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_06_01_02():
    result = parse("G*01:06:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("G*01:06:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("G*01:06:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_07():
    result = parse("G*01:07")
    assert result.__class__ is Allele, f'Expected parse("G*01:07") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_08_01():
    result = parse("G*01:08:01")
    assert result.__class__ is Allele, f'Expected parse("G*01:08:01") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:08:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_08_02():
    result = parse("G*01:08:02")
    assert result.__class__ is Allele, f'Expected parse("G*01:08:02") to be Allele but got {result}'
    assert result.num_allele_fields == 3, (
        'Expected parse("G*01:08:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_09():
    result = parse("G*01:09")
    assert result.__class__ is Allele, f'Expected parse("G*01:09") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_10():
    result = parse("G*01:10")
    assert result.__class__ is Allele, f'Expected parse("G*01:10") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_11():
    result = parse("G*01:11")
    assert result.__class__ is Allele, f'Expected parse("G*01:11") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_12():
    result = parse("G*01:12")
    assert result.__class__ is Allele, f'Expected parse("G*01:12") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_13N():
    result = parse("G*01:13N")
    assert result.__class__ is Allele, f'Expected parse("G*01:13N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:13N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_14():
    result = parse("G*01:14")
    assert result.__class__ is Allele, f'Expected parse("G*01:14") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:14") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_15():
    result = parse("G*01:15")
    assert result.__class__ is Allele, f'Expected parse("G*01:15") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:15") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_16():
    result = parse("G*01:16")
    assert result.__class__ is Allele, f'Expected parse("G*01:16") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:16") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_17():
    result = parse("G*01:17")
    assert result.__class__ is Allele, f'Expected parse("G*01:17") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:17") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_18():
    result = parse("G*01:18")
    assert result.__class__ is Allele, f'Expected parse("G*01:18") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:18") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_19():
    result = parse("G*01:19")
    assert result.__class__ is Allele, f'Expected parse("G*01:19") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:19") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_20():
    result = parse("G*01:20")
    assert result.__class__ is Allele, f'Expected parse("G*01:20") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:20") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_21N():
    result = parse("G*01:21N")
    assert result.__class__ is Allele, f'Expected parse("G*01:21N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:21N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_22():
    result = parse("G*01:22")
    assert result.__class__ is Allele, f'Expected parse("G*01:22") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:22") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_23():
    result = parse("G*01:23")
    assert result.__class__ is Allele, f'Expected parse("G*01:23") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:23") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_24():
    result = parse("G*01:24")
    assert result.__class__ is Allele, f'Expected parse("G*01:24") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:24") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_G_01_25N():
    result = parse("G*01:25N")
    assert result.__class__ is Allele, f'Expected parse("G*01:25N") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("G*01:25N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_HFE_001_01_01():
    result = parse("HFE*001:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("HFE*001:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("HFE*001:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_HFE_001_01_02():
    result = parse("HFE*001:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("HFE*001:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("HFE*001:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_HFE_001_01_03():
    result = parse("HFE*001:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("HFE*001:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("HFE*001:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_HFE_002():
    result = parse("HFE*002")
    assert result.__class__ is Allele, f'Expected parse("HFE*002") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("HFE*002") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_HFE_003():
    result = parse("HFE*003")
    assert result.__class__ is Allele, f'Expected parse("HFE*003") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("HFE*003") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_HFE_004():
    result = parse("HFE*004")
    assert result.__class__ is Allele, f'Expected parse("HFE*004") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("HFE*004") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP1_01_01_01_01():
    result = parse("TAP1*01:01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP1*01:01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("TAP1*01:01:01:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP1_01_01_01_02():
    result = parse("TAP1*01:01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP1*01:01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("TAP1*01:01:01:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP1_01_01_01_03():
    result = parse("TAP1*01:01:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP1*01:01:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("TAP1*01:01:01:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP1_01_01_01_04():
    result = parse("TAP1*01:01:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP1*01:01:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("TAP1*01:01:01:04") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP1_01_01_01_05():
    result = parse("TAP1*01:01:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP1*01:01:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("TAP1*01:01:01:05") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP1_01_02N():
    result = parse("TAP1*01:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP1*01:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("TAP1*01:02N") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP1_02_01_01():
    result = parse("TAP1*02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP1*02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("TAP1*02:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP1_02_01_02():
    result = parse("TAP1*02:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP1*02:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("TAP1*02:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP1_03_01():
    result = parse("TAP1*03:01")
    assert result.__class__ is Allele, f'Expected parse("TAP1*03:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("TAP1*03:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP1_04_01():
    result = parse("TAP1*04:01")
    assert result.__class__ is Allele, f'Expected parse("TAP1*04:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("TAP1*04:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP1_05_01():
    result = parse("TAP1*05:01")
    assert result.__class__ is Allele, f'Expected parse("TAP1*05:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("TAP1*05:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP1_06_01():
    result = parse("TAP1*06:01")
    assert result.__class__ is Allele, f'Expected parse("TAP1*06:01") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("TAP1*06:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP2_01_01_01():
    result = parse("TAP2*01:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP2*01:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("TAP2*01:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP2_01_01_02():
    result = parse("TAP2*01:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP2*01:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("TAP2*01:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP2_01_01_03_01():
    result = parse("TAP2*01:01:03:01")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP2*01:01:03:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("TAP2*01:01:03:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP2_01_01_03_02():
    result = parse("TAP2*01:01:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP2*01:01:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("TAP2*01:01:03:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP2_01_01_03_03():
    result = parse("TAP2*01:01:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP2*01:01:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("TAP2*01:01:03:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP2_01_02():
    result = parse("TAP2*01:02")
    assert result.__class__ is Allele, f'Expected parse("TAP2*01:02") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("TAP2*01:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP2_01_03():
    result = parse("TAP2*01:03")
    assert result.__class__ is Allele, f'Expected parse("TAP2*01:03") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("TAP2*01:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP2_01_04():
    result = parse("TAP2*01:04")
    assert result.__class__ is Allele, f'Expected parse("TAP2*01:04") to be Allele but got {result}'
    assert result.num_allele_fields == 2, (
        'Expected parse("TAP2*01:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP2_02_01_01():
    result = parse("TAP2*02:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP2*02:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("TAP2*02:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP2_02_01_02_01():
    result = parse("TAP2*02:01:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP2*02:01:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("TAP2*02:01:02:01") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP2_02_01_02_02():
    result = parse("TAP2*02:01:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP2*02:01:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("TAP2*02:01:02:02") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_TAP2_02_01_02_03():
    result = parse("TAP2*02:01:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("TAP2*02:01:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 4, (
        'Expected parse("TAP2*02:01:02:03") to have 4 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_001():
    result = parse("MICA*001")
    assert result.__class__ is Allele, f'Expected parse("MICA*001") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*001") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_002_01_01():
    result = parse("MICA*002:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*002:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*002:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_002_01_02():
    result = parse("MICA*002:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*002:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*002:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_002_01_03():
    result = parse("MICA*002:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*002:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*002:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_002_01_04():
    result = parse("MICA*002:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*002:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*002:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_002_01_05():
    result = parse("MICA*002:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*002:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*002:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_002_01_06():
    result = parse("MICA*002:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*002:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*002:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_002_01_07():
    result = parse("MICA*002:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*002:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*002:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_002_01_08():
    result = parse("MICA*002:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*002:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*002:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_002_01_09():
    result = parse("MICA*002:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*002:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*002:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_002_01_10():
    result = parse("MICA*002:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*002:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*002:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_002_02():
    result = parse("MICA*002:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*002:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*002:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_002_03():
    result = parse("MICA*002:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*002:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*002:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_002_04():
    result = parse("MICA*002:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*002:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*002:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_004_01_01():
    result = parse("MICA*004:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*004:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*004:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_004_01_02():
    result = parse("MICA*004:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*004:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*004:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_004_01_03():
    result = parse("MICA*004:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*004:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*004:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_004_01_04():
    result = parse("MICA*004:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*004:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*004:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_004_01_05():
    result = parse("MICA*004:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*004:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*004:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_004_01_06():
    result = parse("MICA*004:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*004:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*004:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_004_01_07():
    result = parse("MICA*004:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*004:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*004:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_004_01_08():
    result = parse("MICA*004:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*004:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*004:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_005():
    result = parse("MICA*005")
    assert result.__class__ is Allele, f'Expected parse("MICA*005") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*005") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_006():
    result = parse("MICA*006")
    assert result.__class__ is Allele, f'Expected parse("MICA*006") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*006") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_007_01_01():
    result = parse("MICA*007:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*007:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*007:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_007_01_02():
    result = parse("MICA*007:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*007:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*007:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_007_01_03():
    result = parse("MICA*007:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*007:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*007:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_007_01_04():
    result = parse("MICA*007:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*007:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*007:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_007_01_05():
    result = parse("MICA*007:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*007:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*007:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_007_01_06():
    result = parse("MICA*007:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*007:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*007:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_007_03():
    result = parse("MICA*007:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*007:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*007:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_007_05():
    result = parse("MICA*007:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*007:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*007:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_007_06_01():
    result = parse("MICA*007:06:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*007:06:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*007:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_007_06_02():
    result = parse("MICA*007:06:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*007:06:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*007:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_007_07():
    result = parse("MICA*007:07")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*007:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*007:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_01_01():
    result = parse("MICA*008:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*008:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_01_02():
    result = parse("MICA*008:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*008:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_01_03():
    result = parse("MICA*008:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*008:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_01_04():
    result = parse("MICA*008:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*008:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_01_05():
    result = parse("MICA*008:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*008:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_01_06():
    result = parse("MICA*008:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*008:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_01_07():
    result = parse("MICA*008:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*008:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_01_08():
    result = parse("MICA*008:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*008:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_01_09():
    result = parse("MICA*008:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*008:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_02():
    result = parse("MICA*008:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*008:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_03():
    result = parse("MICA*008:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*008:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_04_01():
    result = parse("MICA*008:04:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:04:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*008:04:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_04_02():
    result = parse("MICA*008:04:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:04:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*008:04:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_04_03():
    result = parse("MICA*008:04:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:04:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*008:04:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_04_04():
    result = parse("MICA*008:04:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:04:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*008:04:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_04_05():
    result = parse("MICA*008:04:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:04:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*008:04:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_05():
    result = parse("MICA*008:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*008:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_06():
    result = parse("MICA*008:06")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*008:06") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_07():
    result = parse("MICA*008:07")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*008:07") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_08():
    result = parse("MICA*008:08")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*008:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_09():
    result = parse("MICA*008:09")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*008:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_10():
    result = parse("MICA*008:10")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*008:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_11():
    result = parse("MICA*008:11")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*008:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_12():
    result = parse("MICA*008:12")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*008:12") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_008_13():
    result = parse("MICA*008:13")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*008:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*008:13") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_009_01_01():
    result = parse("MICA*009:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*009:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*009:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_009_01_02():
    result = parse("MICA*009:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*009:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*009:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_009_01_03():
    result = parse("MICA*009:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*009:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*009:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_009_01_04():
    result = parse("MICA*009:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*009:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*009:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_009_01_05():
    result = parse("MICA*009:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*009:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*009:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_009_01_06():
    result = parse("MICA*009:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*009:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*009:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_009_02_01():
    result = parse("MICA*009:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*009:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*009:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_009_02_02():
    result = parse("MICA*009:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*009:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*009:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_009_02_03():
    result = parse("MICA*009:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*009:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*009:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_009_03():
    result = parse("MICA*009:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*009:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*009:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_010_01_01():
    result = parse("MICA*010:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*010:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*010:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_010_01_02():
    result = parse("MICA*010:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*010:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*010:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_010_01_03():
    result = parse("MICA*010:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*010:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*010:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_010_01_04():
    result = parse("MICA*010:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*010:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*010:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_010_01_05():
    result = parse("MICA*010:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*010:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*010:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_010_01_06():
    result = parse("MICA*010:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*010:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*010:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_010_02_01():
    result = parse("MICA*010:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*010:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*010:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_010_02_02():
    result = parse("MICA*010:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*010:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*010:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_010_03():
    result = parse("MICA*010:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*010:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*010:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_011_01_01():
    result = parse("MICA*011:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*011:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*011:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_011_01_02():
    result = parse("MICA*011:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*011:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*011:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_011_01_03():
    result = parse("MICA*011:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*011:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*011:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_011_01_04():
    result = parse("MICA*011:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*011:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*011:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_011_01_05():
    result = parse("MICA*011:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*011:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*011:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_011_01_06():
    result = parse("MICA*011:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*011:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*011:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_012_01_01():
    result = parse("MICA*012:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*012:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*012:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_012_01_02():
    result = parse("MICA*012:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*012:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*012:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_012_01_03():
    result = parse("MICA*012:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*012:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*012:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_012_02():
    result = parse("MICA*012:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*012:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*012:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_012_03():
    result = parse("MICA*012:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*012:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*012:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_012_04():
    result = parse("MICA*012:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*012:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*012:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_012_05():
    result = parse("MICA*012:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*012:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*012:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_013():
    result = parse("MICA*013")
    assert result.__class__ is Allele, f'Expected parse("MICA*013") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*013") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_014():
    result = parse("MICA*014")
    assert result.__class__ is Allele, f'Expected parse("MICA*014") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*014") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_015():
    result = parse("MICA*015")
    assert result.__class__ is Allele, f'Expected parse("MICA*015") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*015") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_016():
    result = parse("MICA*016")
    assert result.__class__ is Allele, f'Expected parse("MICA*016") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*016") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_017():
    result = parse("MICA*017")
    assert result.__class__ is Allele, f'Expected parse("MICA*017") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*017") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_018_01_01():
    result = parse("MICA*018:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*018:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*018:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_018_01_02():
    result = parse("MICA*018:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*018:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*018:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_018_01_03():
    result = parse("MICA*018:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*018:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*018:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_018_01_04():
    result = parse("MICA*018:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*018:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*018:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_018_01_05():
    result = parse("MICA*018:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*018:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*018:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_018_01_06():
    result = parse("MICA*018:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*018:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*018:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_018_01_07():
    result = parse("MICA*018:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*018:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*018:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_018_02():
    result = parse("MICA*018:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*018:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*018:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_019_01_01():
    result = parse("MICA*019:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*019:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*019:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_019_01_02():
    result = parse("MICA*019:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*019:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*019:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_019_02():
    result = parse("MICA*019:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*019:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*019:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_020():
    result = parse("MICA*020")
    assert result.__class__ is Allele, f'Expected parse("MICA*020") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*020") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_022_01_01():
    result = parse("MICA*022:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*022:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*022:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_022_01_02():
    result = parse("MICA*022:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*022:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*022:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_023():
    result = parse("MICA*023")
    assert result.__class__ is Allele, f'Expected parse("MICA*023") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*023") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_024():
    result = parse("MICA*024")
    assert result.__class__ is Allele, f'Expected parse("MICA*024") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*024") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_025():
    result = parse("MICA*025")
    assert result.__class__ is Allele, f'Expected parse("MICA*025") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*025") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_026():
    result = parse("MICA*026")
    assert result.__class__ is Allele, f'Expected parse("MICA*026") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*026") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_027_01_01():
    result = parse("MICA*027:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*027:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*027:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_027_01_02():
    result = parse("MICA*027:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*027:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*027:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_028():
    result = parse("MICA*028")
    assert result.__class__ is Allele, f'Expected parse("MICA*028") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*028") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_029_01_01():
    result = parse("MICA*029:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*029:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*029:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_029_01_02():
    result = parse("MICA*029:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*029:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*029:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_029_02():
    result = parse("MICA*029:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*029:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*029:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_030():
    result = parse("MICA*030")
    assert result.__class__ is Allele, f'Expected parse("MICA*030") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*030") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_031():
    result = parse("MICA*031")
    assert result.__class__ is Allele, f'Expected parse("MICA*031") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*031") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_032():
    result = parse("MICA*032")
    assert result.__class__ is Allele, f'Expected parse("MICA*032") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*032") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_033():
    result = parse("MICA*033")
    assert result.__class__ is Allele, f'Expected parse("MICA*033") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*033") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_034():
    result = parse("MICA*034")
    assert result.__class__ is Allele, f'Expected parse("MICA*034") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*034") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_035():
    result = parse("MICA*035")
    assert result.__class__ is Allele, f'Expected parse("MICA*035") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*035") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_036():
    result = parse("MICA*036")
    assert result.__class__ is Allele, f'Expected parse("MICA*036") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*036") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_037():
    result = parse("MICA*037")
    assert result.__class__ is Allele, f'Expected parse("MICA*037") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*037") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_038():
    result = parse("MICA*038")
    assert result.__class__ is Allele, f'Expected parse("MICA*038") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*038") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_039():
    result = parse("MICA*039")
    assert result.__class__ is Allele, f'Expected parse("MICA*039") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*039") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_040():
    result = parse("MICA*040")
    assert result.__class__ is Allele, f'Expected parse("MICA*040") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*040") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_041():
    result = parse("MICA*041")
    assert result.__class__ is Allele, f'Expected parse("MICA*041") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*041") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_042():
    result = parse("MICA*042")
    assert result.__class__ is Allele, f'Expected parse("MICA*042") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*042") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_043():
    result = parse("MICA*043")
    assert result.__class__ is Allele, f'Expected parse("MICA*043") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*043") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_044():
    result = parse("MICA*044")
    assert result.__class__ is Allele, f'Expected parse("MICA*044") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*044") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_045_01_01():
    result = parse("MICA*045:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*045:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*045:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_045_01_02():
    result = parse("MICA*045:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*045:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*045:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_046():
    result = parse("MICA*046")
    assert result.__class__ is Allele, f'Expected parse("MICA*046") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*046") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_047():
    result = parse("MICA*047")
    assert result.__class__ is Allele, f'Expected parse("MICA*047") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*047") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_048():
    result = parse("MICA*048")
    assert result.__class__ is Allele, f'Expected parse("MICA*048") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*048") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_049_01_01():
    result = parse("MICA*049:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*049:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*049:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_049_01_02():
    result = parse("MICA*049:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*049:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*049:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_050():
    result = parse("MICA*050")
    assert result.__class__ is Allele, f'Expected parse("MICA*050") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*050") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_051():
    result = parse("MICA*051")
    assert result.__class__ is Allele, f'Expected parse("MICA*051") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*051") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_052():
    result = parse("MICA*052")
    assert result.__class__ is Allele, f'Expected parse("MICA*052") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*052") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_053_01_01():
    result = parse("MICA*053:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*053:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*053:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_053_01_02():
    result = parse("MICA*053:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*053:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*053:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_053_01_03():
    result = parse("MICA*053:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*053:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*053:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_053_01_04():
    result = parse("MICA*053:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*053:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*053:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_053_01_05():
    result = parse("MICA*053:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*053:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*053:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_054():
    result = parse("MICA*054")
    assert result.__class__ is Allele, f'Expected parse("MICA*054") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*054") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_055():
    result = parse("MICA*055")
    assert result.__class__ is Allele, f'Expected parse("MICA*055") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*055") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_056():
    result = parse("MICA*056")
    assert result.__class__ is Allele, f'Expected parse("MICA*056") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*056") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_057_01_01():
    result = parse("MICA*057:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*057:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*057:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_057_01_02():
    result = parse("MICA*057:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*057:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*057:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_057_01_03():
    result = parse("MICA*057:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*057:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*057:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_057_01_04():
    result = parse("MICA*057:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*057:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*057:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_058():
    result = parse("MICA*058")
    assert result.__class__ is Allele, f'Expected parse("MICA*058") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*058") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_059():
    result = parse("MICA*059")
    assert result.__class__ is Allele, f'Expected parse("MICA*059") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*059") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_060():
    result = parse("MICA*060")
    assert result.__class__ is Allele, f'Expected parse("MICA*060") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*060") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_061():
    result = parse("MICA*061")
    assert result.__class__ is Allele, f'Expected parse("MICA*061") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*061") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_062_01_01():
    result = parse("MICA*062:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*062:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*062:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_062_01_02():
    result = parse("MICA*062:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*062:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*062:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_063N():
    result = parse("MICA*063N")
    assert result.__class__ is Allele, f'Expected parse("MICA*063N") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*063N") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_064N():
    result = parse("MICA*064N")
    assert result.__class__ is Allele, f'Expected parse("MICA*064N") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*064N") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_065():
    result = parse("MICA*065")
    assert result.__class__ is Allele, f'Expected parse("MICA*065") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*065") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_066():
    result = parse("MICA*066")
    assert result.__class__ is Allele, f'Expected parse("MICA*066") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*066") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_067():
    result = parse("MICA*067")
    assert result.__class__ is Allele, f'Expected parse("MICA*067") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*067") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_068_01_01():
    result = parse("MICA*068:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*068:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*068:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_068_01_02():
    result = parse("MICA*068:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*068:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*068:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_069():
    result = parse("MICA*069")
    assert result.__class__ is Allele, f'Expected parse("MICA*069") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*069") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_070():
    result = parse("MICA*070")
    assert result.__class__ is Allele, f'Expected parse("MICA*070") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*070") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_072_01_01():
    result = parse("MICA*072:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*072:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*072:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_072_01_02():
    result = parse("MICA*072:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*072:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*072:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_072_01_03():
    result = parse("MICA*072:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*072:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*072:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_073():
    result = parse("MICA*073")
    assert result.__class__ is Allele, f'Expected parse("MICA*073") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*073") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_074():
    result = parse("MICA*074")
    assert result.__class__ is Allele, f'Expected parse("MICA*074") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*074") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_075():
    result = parse("MICA*075")
    assert result.__class__ is Allele, f'Expected parse("MICA*075") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*075") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_076():
    result = parse("MICA*076")
    assert result.__class__ is Allele, f'Expected parse("MICA*076") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*076") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_077():
    result = parse("MICA*077")
    assert result.__class__ is Allele, f'Expected parse("MICA*077") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*077") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_078():
    result = parse("MICA*078")
    assert result.__class__ is Allele, f'Expected parse("MICA*078") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*078") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_079():
    result = parse("MICA*079")
    assert result.__class__ is Allele, f'Expected parse("MICA*079") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*079") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_080():
    result = parse("MICA*080")
    assert result.__class__ is Allele, f'Expected parse("MICA*080") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*080") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_081():
    result = parse("MICA*081")
    assert result.__class__ is Allele, f'Expected parse("MICA*081") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*081") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_082():
    result = parse("MICA*082")
    assert result.__class__ is Allele, f'Expected parse("MICA*082") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*082") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_083():
    result = parse("MICA*083")
    assert result.__class__ is Allele, f'Expected parse("MICA*083") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*083") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_084():
    result = parse("MICA*084")
    assert result.__class__ is Allele, f'Expected parse("MICA*084") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*084") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_085():
    result = parse("MICA*085")
    assert result.__class__ is Allele, f'Expected parse("MICA*085") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*085") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_086():
    result = parse("MICA*086")
    assert result.__class__ is Allele, f'Expected parse("MICA*086") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*086") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_087():
    result = parse("MICA*087")
    assert result.__class__ is Allele, f'Expected parse("MICA*087") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*087") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_088N():
    result = parse("MICA*088N")
    assert result.__class__ is Allele, f'Expected parse("MICA*088N") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*088N") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_089():
    result = parse("MICA*089")
    assert result.__class__ is Allele, f'Expected parse("MICA*089") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*089") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_090():
    result = parse("MICA*090")
    assert result.__class__ is Allele, f'Expected parse("MICA*090") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*090") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_091():
    result = parse("MICA*091")
    assert result.__class__ is Allele, f'Expected parse("MICA*091") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*091") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_092():
    result = parse("MICA*092")
    assert result.__class__ is Allele, f'Expected parse("MICA*092") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*092") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_093():
    result = parse("MICA*093")
    assert result.__class__ is Allele, f'Expected parse("MICA*093") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*093") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_094():
    result = parse("MICA*094")
    assert result.__class__ is Allele, f'Expected parse("MICA*094") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*094") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_095():
    result = parse("MICA*095")
    assert result.__class__ is Allele, f'Expected parse("MICA*095") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*095") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_096N():
    result = parse("MICA*096N")
    assert result.__class__ is Allele, f'Expected parse("MICA*096N") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*096N") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_097():
    result = parse("MICA*097")
    assert result.__class__ is Allele, f'Expected parse("MICA*097") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*097") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_098_01():
    result = parse("MICA*098:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*098:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*098:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_098_02():
    result = parse("MICA*098:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*098:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*098:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_099_01_01():
    result = parse("MICA*099:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*099:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*099:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_099_01_02():
    result = parse("MICA*099:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*099:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*099:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_100():
    result = parse("MICA*100")
    assert result.__class__ is Allele, f'Expected parse("MICA*100") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*100") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_101():
    result = parse("MICA*101")
    assert result.__class__ is Allele, f'Expected parse("MICA*101") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*101") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_102():
    result = parse("MICA*102")
    assert result.__class__ is Allele, f'Expected parse("MICA*102") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*102") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_103():
    result = parse("MICA*103")
    assert result.__class__ is Allele, f'Expected parse("MICA*103") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*103") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_104():
    result = parse("MICA*104")
    assert result.__class__ is Allele, f'Expected parse("MICA*104") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*104") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_105Q():
    result = parse("MICA*105Q")
    assert result.__class__ is Allele, f'Expected parse("MICA*105Q") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*105Q") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_106():
    result = parse("MICA*106")
    assert result.__class__ is Allele, f'Expected parse("MICA*106") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*106") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_107N():
    result = parse("MICA*107N")
    assert result.__class__ is Allele, f'Expected parse("MICA*107N") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*107N") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_108():
    result = parse("MICA*108")
    assert result.__class__ is Allele, f'Expected parse("MICA*108") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*108") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_109():
    result = parse("MICA*109")
    assert result.__class__ is Allele, f'Expected parse("MICA*109") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*109") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_110():
    result = parse("MICA*110")
    assert result.__class__ is Allele, f'Expected parse("MICA*110") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICA*110") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_111_01():
    result = parse("MICA*111:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*111:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*111:01") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_111_02():
    result = parse("MICA*111:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*111:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICA*111:02") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_112_01_01():
    result = parse("MICA*112:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*112:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*112:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_112_01_02():
    result = parse("MICA*112:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*112:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*112:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_112_01_03():
    result = parse("MICA*112:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*112:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*112:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_112_01_04():
    result = parse("MICA*112:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*112:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*112:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICA_112_01_05():
    result = parse("MICA*112:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICA*112:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICA*112:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_001():
    result = parse("MICB*001")
    assert result.__class__ is Allele, f'Expected parse("MICB*001") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*001") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_01():
    result = parse("MICB*002:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_02():
    result = parse("MICB*002:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_03():
    result = parse("MICB*002:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_04():
    result = parse("MICB*002:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_05():
    result = parse("MICB*002:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_06():
    result = parse("MICB*002:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_07():
    result = parse("MICB*002:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_08():
    result = parse("MICB*002:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_09():
    result = parse("MICB*002:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_10():
    result = parse("MICB*002:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_11():
    result = parse("MICB*002:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_12():
    result = parse("MICB*002:01:12")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:12") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:12") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_13():
    result = parse("MICB*002:01:13")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:13") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:13") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_14():
    result = parse("MICB*002:01:14")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:14") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:14") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_15():
    result = parse("MICB*002:01:15")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:15") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:15") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_16():
    result = parse("MICB*002:01:16")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:16") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:16") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_17():
    result = parse("MICB*002:01:17")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:17") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:17") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_18():
    result = parse("MICB*002:01:18")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:18") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:18") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_19():
    result = parse("MICB*002:01:19")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:19") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:19") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_01_20():
    result = parse("MICB*002:01:20")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:01:20") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:01:20") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_02_01():
    result = parse("MICB*002:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_02_02():
    result = parse("MICB*002:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*002:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_002_03():
    result = parse("MICB*002:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*002:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICB*002:03") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_003_01_01():
    result = parse("MICB*003:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*003:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*003:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_003_01_02():
    result = parse("MICB*003:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*003:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*003:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_003_01_03():
    result = parse("MICB*003:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*003:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*003:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_004_01_01():
    result = parse("MICB*004:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*004:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*004:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_004_01_02():
    result = parse("MICB*004:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*004:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*004:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_004_01_03():
    result = parse("MICB*004:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*004:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*004:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_004_01_04():
    result = parse("MICB*004:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*004:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*004:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_004_01_05():
    result = parse("MICB*004:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*004:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*004:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_004_01_06():
    result = parse("MICB*004:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*004:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*004:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_004_01_07():
    result = parse("MICB*004:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*004:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*004:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_01_01():
    result = parse("MICB*005:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_01_02():
    result = parse("MICB*005:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_02_01():
    result = parse("MICB*005:02:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:02:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:02:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_02_02():
    result = parse("MICB*005:02:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:02:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:02:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_02_03():
    result = parse("MICB*005:02:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:02:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:02:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_02_04():
    result = parse("MICB*005:02:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:02:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:02:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_02_05():
    result = parse("MICB*005:02:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:02:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:02:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_02_06():
    result = parse("MICB*005:02:06")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:02:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:02:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_02_07():
    result = parse("MICB*005:02:07")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:02:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:02:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_02_08():
    result = parse("MICB*005:02:08")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:02:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:02:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_02_09():
    result = parse("MICB*005:02:09")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:02:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:02:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_02_10():
    result = parse("MICB*005:02:10")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:02:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:02:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_02_11():
    result = parse("MICB*005:02:11")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:02:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:02:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_03_01():
    result = parse("MICB*005:03:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:03:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:03:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_03_02():
    result = parse("MICB*005:03:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:03:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:03:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_03_03():
    result = parse("MICB*005:03:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:03:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:03:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_03_04():
    result = parse("MICB*005:03:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:03:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:03:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_03_05():
    result = parse("MICB*005:03:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:03:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:03:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_04():
    result = parse("MICB*005:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICB*005:04") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_05():
    result = parse("MICB*005:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICB*005:05") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_06_01():
    result = parse("MICB*005:06:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:06:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:06:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_06_02():
    result = parse("MICB*005:06:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:06:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:06:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_07_01():
    result = parse("MICB*005:07:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:07:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:07:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_07_02():
    result = parse("MICB*005:07:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:07:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*005:07:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_08():
    result = parse("MICB*005:08")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICB*005:08") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_09():
    result = parse("MICB*005:09")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICB*005:09") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_10():
    result = parse("MICB*005:10")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICB*005:10") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_005_11():
    result = parse("MICB*005:11")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*005:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 2, (
        'Expected parse("MICB*005:11") to have 2 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_006():
    result = parse("MICB*006")
    assert result.__class__ is Allele, f'Expected parse("MICB*006") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*006") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_007():
    result = parse("MICB*007")
    assert result.__class__ is Allele, f'Expected parse("MICB*007") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*007") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_008_01_01():
    result = parse("MICB*008:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*008:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*008:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_008_01_02():
    result = parse("MICB*008:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*008:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*008:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_008_01_03():
    result = parse("MICB*008:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*008:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*008:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_008_01_04():
    result = parse("MICB*008:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*008:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*008:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_008_01_05():
    result = parse("MICB*008:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*008:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*008:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_008_01_06():
    result = parse("MICB*008:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*008:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*008:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_008_01_07():
    result = parse("MICB*008:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*008:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*008:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_008_01_08():
    result = parse("MICB*008:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*008:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*008:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_008_01_09():
    result = parse("MICB*008:01:09")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*008:01:09") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*008:01:09") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_008_01_10():
    result = parse("MICB*008:01:10")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*008:01:10") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*008:01:10") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_008_01_11():
    result = parse("MICB*008:01:11")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*008:01:11") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*008:01:11") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_009N():
    result = parse("MICB*009N")
    assert result.__class__ is Allele, f'Expected parse("MICB*009N") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*009N") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_010():
    result = parse("MICB*010")
    assert result.__class__ is Allele, f'Expected parse("MICB*010") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*010") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_011():
    result = parse("MICB*011")
    assert result.__class__ is Allele, f'Expected parse("MICB*011") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*011") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_012():
    result = parse("MICB*012")
    assert result.__class__ is Allele, f'Expected parse("MICB*012") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*012") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_013_01_01():
    result = parse("MICB*013:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*013:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*013:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_013_01_02():
    result = parse("MICB*013:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*013:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*013:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_013_01_03():
    result = parse("MICB*013:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*013:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*013:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_013_01_04():
    result = parse("MICB*013:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*013:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*013:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_013_01_05():
    result = parse("MICB*013:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*013:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*013:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_014_01_01():
    result = parse("MICB*014:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*014:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*014:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_014_01_02():
    result = parse("MICB*014:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*014:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*014:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_014_01_03():
    result = parse("MICB*014:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*014:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*014:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_014_01_04():
    result = parse("MICB*014:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*014:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*014:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_014_01_05():
    result = parse("MICB*014:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*014:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*014:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_014_01_06():
    result = parse("MICB*014:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*014:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*014:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_015():
    result = parse("MICB*015")
    assert result.__class__ is Allele, f'Expected parse("MICB*015") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*015") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_016():
    result = parse("MICB*016")
    assert result.__class__ is Allele, f'Expected parse("MICB*016") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*016") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_018_01_01():
    result = parse("MICB*018:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*018:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*018:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_018_01_02():
    result = parse("MICB*018:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*018:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*018:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_018_01_03():
    result = parse("MICB*018:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*018:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*018:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_019_01_01():
    result = parse("MICB*019:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*019:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*019:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_019_01_02():
    result = parse("MICB*019:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*019:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*019:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_019_01_03():
    result = parse("MICB*019:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*019:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*019:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_019_01_04():
    result = parse("MICB*019:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*019:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*019:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_019_01_05():
    result = parse("MICB*019:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*019:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*019:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_019_01_06():
    result = parse("MICB*019:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*019:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*019:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_019_01_07():
    result = parse("MICB*019:01:07")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*019:01:07") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*019:01:07") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_019_01_08():
    result = parse("MICB*019:01:08")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*019:01:08") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*019:01:08") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_020_01_01():
    result = parse("MICB*020:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*020:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*020:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_020_01_02():
    result = parse("MICB*020:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*020:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*020:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_020_01_03():
    result = parse("MICB*020:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*020:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*020:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_021_01_01N():
    result = parse("MICB*021:01:01N")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*021:01:01N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*021:01:01N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_021_01_02N():
    result = parse("MICB*021:01:02N")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*021:01:02N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*021:01:02N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_021_01_03N():
    result = parse("MICB*021:01:03N")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*021:01:03N") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*021:01:03N") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_022():
    result = parse("MICB*022")
    assert result.__class__ is Allele, f'Expected parse("MICB*022") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*022") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_023():
    result = parse("MICB*023")
    assert result.__class__ is Allele, f'Expected parse("MICB*023") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*023") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_024_01_01():
    result = parse("MICB*024:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*024:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*024:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_024_01_02():
    result = parse("MICB*024:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*024:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*024:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_024_01_03():
    result = parse("MICB*024:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*024:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*024:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_025_01_01():
    result = parse("MICB*025:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*025:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*025:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_025_01_02():
    result = parse("MICB*025:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*025:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*025:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_025_01_03():
    result = parse("MICB*025:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*025:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*025:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_025_01_04():
    result = parse("MICB*025:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*025:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*025:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_026():
    result = parse("MICB*026")
    assert result.__class__ is Allele, f'Expected parse("MICB*026") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*026") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_027():
    result = parse("MICB*027")
    assert result.__class__ is Allele, f'Expected parse("MICB*027") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*027") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_028():
    result = parse("MICB*028")
    assert result.__class__ is Allele, f'Expected parse("MICB*028") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*028") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_029():
    result = parse("MICB*029")
    assert result.__class__ is Allele, f'Expected parse("MICB*029") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*029") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_030():
    result = parse("MICB*030")
    assert result.__class__ is Allele, f'Expected parse("MICB*030") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*030") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_031_01_01():
    result = parse("MICB*031:01:01")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*031:01:01") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*031:01:01") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_031_01_02():
    result = parse("MICB*031:01:02")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*031:01:02") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*031:01:02") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_031_01_03():
    result = parse("MICB*031:01:03")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*031:01:03") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*031:01:03") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_031_01_04():
    result = parse("MICB*031:01:04")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*031:01:04") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*031:01:04") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_031_01_05():
    result = parse("MICB*031:01:05")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*031:01:05") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*031:01:05") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_031_01_06():
    result = parse("MICB*031:01:06")
    assert result.__class__ is Allele, (
        f'Expected parse("MICB*031:01:06") to be Allele but got {result}'
    )
    assert result.num_allele_fields == 3, (
        'Expected parse("MICB*031:01:06") to have 3 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_032():
    result = parse("MICB*032")
    assert result.__class__ is Allele, f'Expected parse("MICB*032") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*032") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_033():
    result = parse("MICB*033")
    assert result.__class__ is Allele, f'Expected parse("MICB*033") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*033") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_034():
    result = parse("MICB*034")
    assert result.__class__ is Allele, f'Expected parse("MICB*034") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*034") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_035():
    result = parse("MICB*035")
    assert result.__class__ is Allele, f'Expected parse("MICB*035") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*035") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_036():
    result = parse("MICB*036")
    assert result.__class__ is Allele, f'Expected parse("MICB*036") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*036") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_037():
    result = parse("MICB*037")
    assert result.__class__ is Allele, f'Expected parse("MICB*037") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*037") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_038():
    result = parse("MICB*038")
    assert result.__class__ is Allele, f'Expected parse("MICB*038") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*038") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_039():
    result = parse("MICB*039")
    assert result.__class__ is Allele, f'Expected parse("MICB*039") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*039") to have 1 field(s) but got %d'
    ) % result.num_allele_fields


def test_MICB_040():
    result = parse("MICB*040")
    assert result.__class__ is Allele, f'Expected parse("MICB*040") to be Allele but got {result}'
    assert result.num_allele_fields == 1, (
        'Expected parse("MICB*040") to have 1 field(s) but got %d'
    ) % result.num_allele_fields
